Comment optimiser le code et les ressources avec R8 dans vos applications Android

Dernière mise à jour: Novembre 18 2026
  • R8 supprime le code et les ressources inutilisés, réécrit le reste et raccourcit les noms pour créer des applications plus petites, avec des temps de démarrage plus rapides et moins de problèmes de non-réactivité.
  • Il est conseillé d'activer l'optimisation dans la version finale et d'ajuster les règles de conservation, qui constituent le principal obstacle empêchant R8 de fonctionner à pleine capacité.
  • L'analyseur de configuration de R8 mesure la quantité de code disponible pour être réduite, optimisée et obscurcie, et signale les règles trop larges, dupliquées ou inutiles.
  • L'utilisation d'App Bundles, d'images légères, d'ajustements de langue et de densité, ainsi que la mesure constante de la taille, permettent d'optimiser la vitesse de téléchargement.

Développeur d'applications Android travaillant sur de la documentation technique sur un MacBook dans un environnement professionnel.

La compression d'une application Android ne se limite pas à la suppression de fichiers individuels ; il s'agit d'un équilibre subtil entre la taille, la vitesse de démarrage et l'utilisation de la mémoire. L'optimiseur intégré d'Android, R8, prend en charge une grande partie de ce travail sans que vous ayez à écrire une seule ligne de code : il analyse le code et les ressources réellement utilisés, supprime ceux qui ne servent à rien et réécrit le reste pour une exécution plus fluide. Les utilisateurs de votre application constatent ainsi des temps de démarrage plus courts, une consommation de mémoire réduite, une interface plus fluide et moins de messages d'erreur.

L'essentiel est de lui laisser de la marge de manœuvre. Plus la portion de votre code que R8 peut modifier est importante, meilleurs seront les résultats. Les règles de conservation trop générales constituent l'obstacle le plus fréquent , car elles figent les classes et les méthodes qui ne sont pas nécessairement appelées dynamiquement, ainsi que leurs dépendances. Affiner ces règles, mesurer et tester à nouveau, c'est le processus itératif qui distingue une application simplement publiée d'une application véritablement optimisée.

Que fait exactement R8 et pourquoi devriez-vous lui faire confiance ?

Écran d'ordinateur portable affichant du code et des outils d'analyse de données, représentant le processus d'optimisation avec R8.

R8 fonctionne en plusieurs phases liées. Tout d'abord, il analyse vos points d'entrée réels, tels que les activités ou services déclarés dans le manifeste, construit une carte de toutes les références et supprime celles qui n'y figurent pas . Ensuite, il procède à des optimisations logiques : remplacement des appels par le corps de la méthode appelée, fusion des classes et des interfaces, simplification des structures et réduction de la surcharge d'exécution. Enfin, il raccourcit les noms des classes, des champs et des méthodes ; ainsi, `com.example.MyActivity` peut devenir `aba`, ce qui permet de réduire la taille des métadonnées.

  • Moins de code mortLes dépendances que vous n'utilisez qu'en faible pourcentage cessent d'avoir toute leur importance.
  • Exécution plus efficaceL'insertion de méthodes et la fusion de classes réduisent les appels et la pression sur la mémoire.
  • Fichiers DEX plus légersL'obfuscation permet de sauvegarder les métadonnées et d'accélérer le chargement des classes.
  • Ressources ajustéesDepuis la version 8.12 du plugin Gradle, R8 participe également à l'optimisation des ressources.

Du point de vue de l'utilisateur, cela se traduit par des temps de démarrage plus rapides, une consommation de mémoire réduite, un rendu amélioré et moins de problèmes de blocage de l'application. La recommandation officielle est claire : activez l'optimisation dans la version finale . Pour les tests quotidiens ou le développement de bibliothèques, cela n'est généralement pas pertinent, car le temps de compilation augmente et le débogage se complexifie lorsque les noms changent.

Activer l'optimisation en fonction de la version du plugin Gradle

Si vous utilisez les versions récentes du plugin Android pour Gradle, la procédure est grandement simplifiée. Il suffit d'activer une seule option dans le bloc d'optimisation du type de build « release » et de placer vos règles de conservation dans un répertoire spécifique, avec des fichiers se terminant par `.keep`, par exemple dans `src/main/keepRules`. Cette nouvelle approche concerne à la fois le code et les ressources et inclut des règles de plateforme par défaut équivalentes aux anciennes règles ProGuard avec optimisation ; il n'est donc pas nécessaire de déclarer de fichiers supplémentaires.

Dans les projets utilisant des versions antérieures du plugin, la méthode standard consiste à paramétrer deux options dans le type de build de publication : l’une active la minification du code et l’autre la réduction des ressources. Il est recommandé d’activer les deux simultanément et d’ajouter le fichier de règles optimisé généré par le système, ainsi que votre propre fichier de règles si nécessaire. Utiliser des builds de publication sans ces options est un moyen insidieux d’alourdir inutilement la mémoire de vos utilisateurs.

réduction des ressources en mode complet et optimisée

Le mode complet de R8 est activé par défaut depuis des années et applique des règles plus strictes concernant l'utilisation de la réflexion et des appels dynamiques. Si une propriété le désactive, il est fortement conseillé de la supprimer : la désactiver limite le potentiel de l'optimiseur. Cependant, le mode complet peut nécessiter des règles supplémentaires dans les projets comportant beaucoup de code dynamique ; il est donc impératif de toujours le tester avec une version finale et non uniquement avec des tests unitaires.

  Questions d'entretien sur SQL et Python dans le secteur de la publicité numérique : un guide complet

La réduction optimisée des ressources a été introduite avec la version 8.12 du plugin et, depuis la version 9.0, elle est appliquée automatiquement lorsque cette fonctionnalité est activée. Le principe est de considérer les ressources comme faisant partie intégrante du graphe de code : auparavant, l’outil de packaging générait des règles de préservation qui maintenaient en vie les ressources inaccessibles et le code qui se référençait mutuellement ; désormais, si un ensemble de code et de ressources n’est pas utilisé, il n’est pas protégé et disparaît. Dans les applications présentant de nombreuses variations de format, des réductions de taille supérieures à 50 % ont été constatées.

L'analyseur de configuration R8 et ses trois scores

Gros plan sur un smartphone doté d'une interface d'application minimaliste, fluide et optimisée.

Cet analyseur vous indique si votre configuration est bénéfique ou nuisible. Il génère des statistiques sur le pourcentage de votre code source susceptible d'être réduit, optimisé et obfusqué . Un score de réduction de 66 % signifie que R8 peut supprimer du code des deux tiers de votre code source ; avec le même score d'optimisation, il ne peut appliquer l'insertion de méthodes, la fusion de classes et d'autres techniques qu'aux deux tiers restants. Le score d'obfuscation mesure la quantité de code pouvant être raccourcie pour préserver les métadonnées.

Outre les indicateurs globaux, le rapport détaille l'impact de chaque règle de conservation et les propriétés d'optimisation qu'elle bloque. Il identifie également les règles provenant de bibliothèques tierces , ce qui est très utile car les auteurs de ces bibliothèques ne connaissent pas votre implémentation spécifique et rédigent parfois des règles si générales qu'elles paralysent l'optimisation de parties de votre application qui n'ont absolument rien à voir avec sa fonctionnalité.

Comment générer le rapport sans perdre de temps

Pour itérer rapidement sur vos règles, une tâche Gradle spécifique analyse la configuration de la version sans créer de package APK ni de bundle. Le cycle de retour d'information est ainsi beaucoup plus court et le rapport HTML apparaît dans le dossier « reports » du module, dans un répertoire dédié à R8. Cette option est recommandée pour affiner vos règles et observer l'effet immédiat de chaque modification.

Si vous préférez l'analyse automatique, chaque version génère également un fichier HTML dans les résultats de la cartographie. Vous pouvez désactiver cette génération automatique via la propriété expérimentale correspondante si vous la jugez gênante. Dans les versions antérieures du plugin, la solution consiste à ajouter une version récente de R8 au classpath du projet et à exécuter la compilation avec une propriété système spécifiant le répertoire d'enregistrement du rapport.

Affinez les règles de conservation sans enfreindre l'application

L'objectif est de préserver uniquement ce qui est réellement accessible par réflexion, ni plus, ni moins. Commencez par examiner les règles qui bloquent l'optimisation dans un grand nombre de classes , en vérifiant les éléments qu'elles protègent et en vous assurant qu'elles ne sont pas effectivement appelées dynamiquement. Ensuite, restreignez le périmètre : au lieu de préserver un package entier avec tous ses membres, limitez la règle à des classes et des membres spécifiques. Enfin, avant d'implémenter la modification, exécutez des tests couvrant les classes, champs et méthodes concernés.

Attention également aux règles subsumées. Si une règle protège un package entier et une autre une classe au sein de ce package, la seconde est inutile et la première bloque des optimisations superflues. Déterminez laquelle des deux est correcte : si la règle spécifique est bien rédigée, supprimez la règle générale et déverrouillez le reste du package ; si la règle générale est correcte, supprimez-la tout de même, mais réécrivez-la pour qu'elle n'affecte que l'essentiel. Relancez ensuite l'analyseur et compilez une version complète pour vérifier que tout fonctionne correctement.

Règles dupliquées, inutilisées et de bibliothèque

L'analyseur identifie deux sources principales d'encombrement : les règles qui ne correspondent à aucune classe, méthode ou champ de la configuration actuelle, et les règles identiques répétées dans un même fichier ou dans des fichiers différents. Les premières sont souvent laissées de côté après une refactorisation ou la suppression de dépendances ; les secondes compliquent la maintenance sans apporter aucun avantage. Leur suppression rend la configuration plus lisible et plus facile à déboguer.

Avec les bibliothèques tierces, la marge de manœuvre est réduite car leurs règles sont intégrées et il est impossible de les modifier sélectivement. La solution pratique consiste à documenter l'impact dans un rapport et à en informer le responsable de la maintenance , ou à reproduire temporairement ces règles dans votre projet, en excluant les plus générales, et à évaluer le gain potentiel avant de décider si le risque est justifié.

  Guide complet de LEGO Education SPIKE Prime

ProGuard et R8 : similaires, mais pas identiques

Pendant des années, ProGuard a accompli quatre tâches : supprimer les éléments inutilisés, optimiser le bytecode, obfusquer les noms et ajouter des informations de pré-vérification. R8 reprend le flambeau et va plus loin : il insère les méthodes de manière plus systématique, fusionne les classes, convertit les énumérations en entiers lorsque c’est possible et exploite mieux les fonctionnalités de Kotlin . La compilation est également plus rapide et, grâce à l’allègement de la bibliothèque principale, il permet l’utilisation des API Java modernes sur les anciennes versions d’Android.

Concernant les règles, R8 accepte celles de ProGuard et ajoute ses propres modificateurs, notamment ceux qui imposent ou empêchent l'insertion d'une méthode spécifique. La conversion des noms ne modifie pas le comportement, mais elle complique la lecture des traces de pile : elle conserve systématiquement le fichier de correspondance pour chaque version afin de pouvoir restaurer la trace originale en cas de défaillance en production.

Erreurs courantes lors de la minification et comment s'en sortir

Les mêmes problèmes persistent : « classe introuvable » suite à la suppression d’une classe, « méthode inexistante » suite au renommage d’une méthode, modèles non sérialisés car leur nom a été perdu, ou bibliothèques qui présupposent une stabilité. Le diagnostic consiste presque toujours à vérifier les accès par réflexion et à ajouter la règle minimale nécessaire . Pour approfondir l’investigation, activez l’affichage de l’utilisation, de la graine et du mappage dans un fichier temporaire, ou désactivez temporairement certaines optimisations afin d’isoler la cause du problème.

Il est également important de noter que les outils externes qui régénèrent ou modifient les fichiers DEX peuvent compromettre les optimisations soigneusement mises en œuvre par R8. Si votre chaîne de compilation inclut une telle étape, vérifiez-la avant d'incriminer l'optimiseur . Enfin, si les performances de compilation vous préoccupent, des ajustements sont possibles pour adapter R8 à votre environnement sans en perdre les avantages.

Réduire les ressources : images, densités et langues

Les ressources représentent généralement une part importante du package. La conversion des bitmaps en WebP réduit la taille du fichier tout en préservant la qualité , et les ressources vectorielles évitent la duplication de la même icône pour chaque densité. Configurer uniquement les densités réellement utilisées et limiter les langues incluses réduit considérablement la taille du fichier, notamment pour les applications comportant de nombreuses traductions. Pour les PNG non convertibles, il existe des utilitaires de compression avec une perte minimale.

Cela permet également de colorer par programmation une seule ressource en niveaux de gris au lieu de regrouper plusieurs versions colorées, de charger à la demande, au démarrage, les images volumineuses et inutiles, et de supprimer les ressources orphelines grâce à l'inspection de code de l'IDE. Si une ressource est référencée uniquement par du code mort, la réduction optimisée la détecte et la supprime , ce qui n'était pas le cas auparavant car les deux processus s'exécutaient séparément.

Agencements, styles et hiérarchies de vues

L'aplatissement des hiérarchies ne réduit pas la taille de l'APK, mais améliore les performances, ce qui constitue l'autre moitié de l'objectif. Remplacez les imbrications de conteneurs inutiles par un ConstraintLayout bien conçu , extrayez les composants communs avec include et définissez des styles pour éviter les attributs dupliqués. L'inspecteur de mise en page vous aide à détecter les arborescences de vues excessivement profondes qui ralentissent le déploiement.

App Bundles, modules dynamiques et bibliothèques natives

La publication au format bundle change la donne : la boutique génère des packages adaptés à chaque appareil, permettant ainsi à chaque utilisateur de télécharger uniquement le code et les ressources nécessaires. Le nombre de téléchargements est nettement inférieur à celui d'un APK universel, car ce format filtre les langues, les densités d'écran et les architectures non pertinentes. De plus, les fonctionnalités peuvent être réparties dans des modules téléchargeables à la demande, selon des critères conditionnels ou instantanés.

Concernant les bibliothèques natives, n'inclure que les architectures prises en charge et activer la compression vous évite d'inclure des binaires inutilisables. Si vous compilez avec Bazel au lieu de Gradle, vous pouvez également intégrer R8 au pipeline, même s'il est important de noter que cette fonctionnalité n'est pas officiellement prise en charge pour le développement d'applications Android.

Mesurer la taille et suivre l'évolution

Tableau de bord d'analyse des performances sur un ordinateur portable, illustrant la mesure des ressources et de la taille de l'application.

Sans mesure, point d'optimisation. L'analyseur APK de l'IDE affiche la taille réelle du package, et une tâche Gradle personnalisée peut la signaler après chaque compilation. L'ajout de cette vérification à l'intégration continue automatise le contrôle de la taille et empêche l'ajout de nouvelles dépendances d'alourdir le binaire sans que personne ne s'en aperçoive.

Comment le comportement a-t-il évolué d'une version à l'autre ?

Il est utile d'examiner l'évolution récente, car elle explique de nombreuses configurations héritées devenues obsolètes. La version 8.0 activait le mode complet par défaut ; la version 8.6 a amélioré le traçage, notamment au niveau des fichiers et des lignes pour tout minSdk ; la version 8.12 a introduit une réduction optimisée des ressources et le traçage automatique dans Logcat ; la version 9.0 l'a activé par défaut, a filtré les options globales dans les règles de consommation et a optimisé la vérification des valeurs nulles en Kotlin ; la version 9.1 a reconditionné les classes par défaut ; et la version 9.3 a introduit le bloc d'optimisation simplifié et l'ensemble de règles `.keep`.

  Guide complet d'installation de WLED sur ESP32 et de contrôle de vos LED

En gardant tout cela à l'esprit, ce qui fait vraiment la différence, c'est une routine simple : activer l'optimisation lors du déploiement, consulter régulièrement le rapport d'analyse, supprimer les règles inutiles, nettoyer les ressources et les images, distribuer l'application via des bundles et mesurer sa taille à chaque mise à jour. Ce sont de petites actions qui, mises bout à bout, transforment une application lourde et lente en une application qui se télécharge et se lance instantanément . Et comme le code et les dépendances ne cessent de croître, la revue doit être continue : ce qui est optimisé aujourd'hui devient obsolète dès qu'une nouvelle bibliothèque est ajoutée ou qu'une fonctionnalité avec ses propres ressources est intégrée.

TecnoDigital

TecnoDigital

Passionné par la technologie et le développement logiciel, je m'immerge dans le monde des systèmes et de l'informatique dans le but de favoriser l'innovation et de résoudre des défis complexes.

Questions fréquentes

Que fait exactement R8 avec le code de mon application ?

Il analyse les points d'entrée déclarés, construit une table de correspondance et supprime tout ce qui n'est pas accessible depuis ces points. Ensuite, il réécrit le code restant pour réduire la surcharge et raccourcit les noms de classes, de champs et de méthodes afin de gagner de la place.

Comment activer l'optimisation R8 dans les dernières versions du plugin Gradle ?

Elle s'active à l'aide d'un indicateur dans le bloc d'optimisation du type de build de production, qui couvre à la fois le code et les ressources. Vos propres règles sont définies dans un ensemble de code source spécifique, dans des fichiers avec l'extension .keep.

Quelle est la différence entre réduire le code et réduire les ressources ?

La réduction du code élimine les classes, champs et méthodes inaccessibles, tandis que la réduction des ressources supprime les images, mises en page et autres fichiers inutilisés. Dans les versions modernes, ces deux tâches sont intégrées dans un graphe de référence unique, évitant ainsi la conservation de ressources liées provenant uniquement de code obsolète.

À quoi sert l'analyseur de configuration R8 ?

Mesurez le pourcentage de votre code source disponible pour la réduction, l'optimisation et l'obfuscation, et analysez l'impact de chaque règle de préservation. Ces données vous permettront d'identifier les règles trop générales, les doublons et les règles devenues obsolètes.

Pourquoi une règle de conservation générale nuit-elle aux performances de mon application ?

Car cela empêche R8 de modifier non seulement ce que cette règle protège, mais aussi tout ce qui en dépend. Il en résulte un volume de code plus important dans le paquet, davantage de métadonnées et moins de marge de manœuvre pour l'insertion de méthodes ou la fusion de classes.

Vaut-il mieux publier avec des App Bundles plutôt qu'avec un APK universel ?

Oui, car la boutique génère des paquets adaptés à chaque appareil, et chaque utilisateur ne télécharge que les ressources de langue, de densité et d'architecture dont il a besoin. Cet ajustement réduit considérablement la taille du téléchargement sans que vous ayez à gérer des fichiers séparés.

Comment puis-je lire la trace de la pile d'exécution d'une version obfusquée ?

Vous avez besoin du fichier de mappage généré à chaque nouvelle version et pour appliquer l'outil de traçage R8. Les versions récentes effectuent même un traçage automatique dans la fenêtre Logcat de l'IDE.

Est-il judicieux d'optimiser une bibliothèque que je vais publier ?

L'optimisation complète est optimale lorsque R8 analyse l'intégralité du graphe d'application ; l'essentiel du travail est donc effectué lors de la compilation de l'application finale. Toutefois, une bibliothèque peut concevoir avec soin ses règles de consommation afin d'éviter de bloquer les optimisations dans les projets qui l'intègrent.