Modifier l'icône d'application

1. Avant de commencer

Une icône d'application est un outil essentiel pour faire ressortir votre application. Elle s'affiche à plusieurs endroits, y compris sur l'écran d'accueil, sur l'écran "Toutes les applications" et dans l'application Paramètres.

L'icône d'application est parfois appelée aussi "icône de lanceur". Le terme "lanceur" désigne ce qui se passe lorsque vous appuyez sur le bouton Accueil d'un appareil Android pour afficher et organiser vos applications, ajouter des widgets et des raccourcis, et plus encore.

Si vous avez essayé différents appareils Android, vous avez peut-être remarqué que l'interface varie parfois en fonction du fabricant. Parfois, les fabricants d'appareils créent une expérience de lancement personnalisée et propre à leur marque. Par conséquent, ils peuvent utiliser des icônes d'application différentes de celles qui sont affichées ci-dessus.

Par exemple, ils peuvent choisir d'afficher toutes les icônes des applications sous forme de carré, de carré arrondi ou de "squircle" (fusion d'un carré et d'un cercle).

Quelle que soit la forme choisie par les fabricants d'appareils, l'objectif est que toutes les icônes d'applications d'un même appareil aient une forme homogène pour une expérience utilisateur plus cohérente.

C'est pourquoi la plate-forme Android accepte les icônes adaptatives (à partir du niveau d'API 26). En ajoutant une icône adaptative à votre application, cette dernière s'adapte à un grand nombre d'appareils en affichant une icône d'application appropriée de haute qualité.

Cet atelier de programmation fournit des fichiers image sources que vous pouvez vous entraîner à utiliser pour l'icône de lanceur d'une calculatrice de pourboires. Un outil Android Studio appelé Image Asset Studio vous permettra de générer toutes les versions des icônes de lanceur nécessaires. Par la suite, vous pourrez ensuite mettre en pratique ce que vous avez appris en modifiant l'icône d'autres applications.

Conditions préalables

Vous savez parcourir les fichiers d'un projet Android de base, y compris les fichiers de ressources.
Vous savez installer une application Android depuis Android Studio dans l'émulateur ou sur un appareil physique.

Points abordés

Modifier l'icône de lanceur d'une application
Utiliser Image Asset Studio dans Android Studio pour générer des éléments d'icône de lanceur.
Découvrir ce qu'est une icône adaptative et pourquoi elle se compose de deux calques

Objectifs de l'atelier

Application Android avec une nouvelle icône de lanceur

Ce dont vous avez besoin

Un ordinateur exécutant la dernière version stable d'Android Studio
Connexion Internet permettant de télécharger les fichiers de ressources d'image

2. Configurer votre projet

Si vous suivez cet atelier de programmation dans le cadre du cours Principes de base d'Android en Kotlin, vous pouvez vous servir directement de la calculatrice de pourboire de l'atelier de programmation précédent sur lequel vous travaillez déjà.

Si vous suivez cet atelier de programmation seul (en dehors du cours), vous pouvez configurer un nouveau projet dans Android Studio à l'aide du modèle Activité vide. De cette manière, vous ne modifierez pas et ne remplacerez pas les fichiers d'icône de lanceur d'une application existante, ce qui est préférable tant que vous ne maîtrisez pas complètement ce processus.

3. Icônes de lanceur

L'objectif est de faire en sorte que l'icône de lanceur soit exceptionnelle (nette et claire), quel que soit le modèle de l'appareil ou la densité de son écran. Dans ce contexte, la densité des pixels correspond au nombre de pixels par pouce (ou ppp, points par pouce) affichés à l'écran. Pour un appareil à densité moyenne (mdpi), 160 ppp sont affichés à l'écran, tandis qu'un appareil à extra-extra-extra-haute densité (xxxhdpi) compte 640 ppp.

Pour tenir compte des appareils utilisant différentes densités d'écran, vous devez fournir différentes versions de l'icône d'application.

Explorer les fichiers d'icône de lanceur

Pour illustrer notre propos, ouvrez le projet dans Android Studio. Si votre application a été lancée à partir d'un modèle, des icônes de lanceur par défaut sont déjà fournies par Android Studio.
Dans la fenêtre Projet, passez à la vue Projet. Les fichiers du projet s'affichent conformément à la structure selon laquelle ils sont enregistrés sur votre ordinateur.

Accédez au répertoire des ressources (app > src > main > res), puis développez certains des dossiers mipmap. C'est dans ces dossiers mipmap que vous devez placer les éléments de l'icône de lanceur pour votre application Android.

mdpi, hdpi, xhdpi, etc. sont des qualificatifs de densité que vous pouvez ajouter au nom d'un répertoire de ressources (comme mipmap) pour indiquer qu'il s'agit de ressources pour les appareils disposant d'une densité d'écran spécifique. Voici la liste des qualificatifs de densité sur Android :

mdpi : ressources pour les écrans de densité moyenne (environ 160 ppp)
hdpi : ressources pour les écrans haute densité (environ 240 ppp)
xhdpi : ressources pour les écrans extra-haute densité (environ 320 ppp)
xxhdpi : ressources pour les écrans extra-extra-haute densité (environ 480 ppp)
xxxhdpi : ressources pour les écrans extra-extra-extra-haute densité (environ 640 ppp)
nodpi : ressources qui ne sont pas destinées à être mises à l'échelle, quelle que soit la densité de pixels de l'écran
anydpi : ressources pouvant s'adapter à n'importe quelle densité

Si vous cliquez sur les fichiers image, un aperçu s'affiche. Les fichiers ic_launcher.png contiennent la version carrée de l'icône, tandis que les fichiers ic_launcher_round.png contiennent la version circulaire. Les deux sont fournis dans chaque répertoire de ressources.

Par exemple, voici ce à quoi ressemble res > mipmap-xxxhdpi > ic_launcher_round.png. Notez également que la taille de l'élément est indiquée en haut à droite. La taille de cette image est de 192 x 192 pixels.

En revanche, voici ce à quoi ressemble res > mipmap-mdpi > ic_launcher_round.png. La taille de l'image ne fait que 48 x 48 pixels.

Comme vous pouvez le voir, ces fichiers image bitmap sont composés d'une grille de pixels fixe. Ils ont été créés pour une résolution d'écran donnée. La qualité peut donc se dégrader lorsque vous les redimensionnez.

Si vous réduisez la taille d'une image bitmap, vous obtiendrez probablement un résultat correct, car vous supprimez des informations de pixel. Si vous augmentez considérablement la taille d'une image bitmap, celle-ci risque d'être floue, car Android devra deviner les informations de pixel manquantes et les fournir.

Maintenant que vous en savez un peu plus sur les icônes de lanceur, intéressons-nous aux icônes adaptatives.

4. Icônes adaptatives

Calque de premier plan et calque d'arrière-plan

Les icônes de lanceur adaptatives peuvent être utilisées depuis la version Android 8.0 (API de niveau 26). Elles offrent davantage de flexibilité et des effets visuels intéressants pour les icônes d'application. Du point de vue du développement, cela signifie que l'icône d'application est composée de deux calques : un calque de premier plan et un calque d'arrière-plan.

Dans l'exemple ci-dessus, l'icône Android blanche se trouve dans le calque de premier plan, tandis que la grille bleue et blanche est dans le calque d'arrière-plan. Le calque de premier plan est superposé au calque d'arrière-plan. Puis, un masque (circulaire dans le cas présent) est appliqué au-dessus pour générer une icône d'application circulaire.

Explorer les fichiers d'icônes adaptatives

Examinez les fichiers d'icône adaptative fournis par défaut par le modèle de projet dans Android Studio.

Dans la fenêtre Project (Projet) d'Android Studio, recherchez le répertoire de ressources res > mipmap-anydpi-v26 et développez-le.

Ouvrez l'un des fichiers XML, par exemple ic_launcher.xml. Voici ce que vous devriez voir :

<?xml version="1.0" encoding="utf-8"?>
<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
    <background android:drawable="@drawable/ic_launcher_background" />
    <foreground android:drawable="@drawable/ic_launcher_foreground" />
</adaptive-icon>

Notez que l'élément <adaptive-icon> permet de déclarer les calques <background> et <foreground> de l'icône d'application en fournissant des ressources drawable pour chacun.
Revenez à la vue Projet et recherchez l'emplacement où les drawables sont déclarés : drawable > ic_launcher_background.xml et drawable-v24 > ic_launcher_foreground.xml.
Passez à la vue Design (Conception) pour afficher un aperçu de chacun d'eux (l'arrière-plan sur la gauche et le premier plan sur la droite).

Il s'agit de fichiers drawable vectoriels. Leur taille n'est pas définie en pixels. Si vous passez à la vue Code, vous pouvez voir la déclaration XML du drawable vectoriel à l'aide de l'élément <vector>.

Bien qu'un objet drawable vectoriel et une image bitmap décrivent tous les deux un graphique, il existe des différences notoires.

Une image bitmap ne sait pas grand-chose sur l'image qu'elle contient. Elle connaît tout au plus les informations de couleur de chaque pixel. En revanche, un graphique vectoriel sait comment dessiner les formes qui définissent une image. Ces instructions sont constituées d'un ensemble de points, de lignes et de courbes, ainsi que d'informations sur les couleurs. L'avantage est qu'un graphique vectoriel peut être adapté à n'importe quelle taille de canevas pour n'importe quelle densité d'écran, sans perte de qualité.

Un drawable vectoriel est une implémentation Android de graphiques vectoriels, conçue pour être suffisamment flexible sur les appareils mobiles. Vous pouvez les définir en XML avec ces éléments possibles. Au lieu de fournir différentes versions d'un élément bitmap pour tous les niveaux de densité, vous n'avez besoin de définir l'image qu'une seule fois. Vous réduisez ainsi la taille de votre application et facilitez sa gestion.

Voyons maintenant comment modifier l'icône d'application.

5. Télécharger de nouveaux éléments

Téléchargez ensuite ces deux nouveaux éléments qui vous permettront de créer une icône adaptative pour une application de calcul de pourboire. Vous n'avez pas besoin de comprendre tous les détails des fichiers drawable vectoriels. Leurs contenus peuvent être générés automatiquement à partir d'outils de conception.

Téléchargez ic_launcher_background.xml, qui correspond au drawable vectoriel du calque d'arrière-plan. Si votre navigateur affiche le fichier au lieu de le télécharger, sélectionnez File > Save Page As (Fichier > Enregistrer la page sous) pour l'enregistrer sur votre ordinateur.
Téléchargez ic_launcher_foreground.xml, qui correspond au drawable vectoriel du calque de premier plan.

Notez que ces éléments de calques de premier plan et d'arrière-plan doivent respecter certaines exigences. Leur taille doit être de 108 dp x 108 dp. Pour en savoir plus sur ces exigences, consultez les conseils de conception pour les icônes Android sur le site Material.

Étant donné que les bords de l'icône peuvent être tronqués en fonction de la forme du masque utilisé par le fabricant de l'appareil, il est important de placer les informations clés qui la concerne dans une zone de sûreté, à savoir un cercle de 66 dp de diamètre au centre de la couche. Veillez à ce que le contenu qui se trouve en dehors de cette zone de sûreté ne soit pas essentiel (par exemple, une couleur d'arrière-plan) et qu'il puisse être tronqué sans que cela ne pose problème.

6. Modifier l'icône d'application

Retournez dans Android Studio afin d'utiliser les nouveaux éléments.

Commencez par supprimer les anciennes ressources drawable comportant l'icône Android et la grille verte comme arrière-plan. Dans la vue Project (Projet), effectuez un clic droit sur le fichier et sélectionnez Supprimer.

Supprimez ce code :

drawable/ic_launcher_background.xml
drawable-v24/ic_launcher_foreground.xml

Vous pouvez désélectionner la case Safe delete (with usage search) (Suppression sécurisée [avec recherche de données d'utilisation]), puis cliquer sur OK.

Créez une ressource d'image. Vous pouvez faire un clic droit sur le répertoire res, puis sélectionner New > Image Asset (Nouveau > Élément Image). Vous pouvez également cliquer sur l'onglet Resource Manager (Gestionnaire de ressources), sur l'icône +, puis sélectionner Image Asset (Élément Image).

L'outil Image Asset Studio d'Android Studio s'ouvre.
Conservez les paramètres par défaut :

Type d'icône : icônes de lanceur (adaptatives et anciennes)

Name (Nom) : ic_launcher

Dans l'onglet Élément Image (Calque de premier plan) déjà sélectionné, accédez à la sous-section Source Asset (Ressource source). Dans le champ Chemin d'accès, cliquez sur l'icône de dossier.
Une invite s'affiche pour vous permettre de parcourir votre ordinateur et de sélectionner un fichier. Localisez l'emplacement du nouveau fichier ic_launcher_foreground.xml que vous venez de télécharger sur votre ordinateur. Il se peut qu'il se trouve dans le dossier "Téléchargements". Une fois que vous l'avez localisé, cliquez sur Open (Ouvrir).
Le chemin d'accès est maintenant mis à jour avec l'emplacement du nouveau drawable vectoriel de premier plan. Le nom du calque doit rester défini sur ic_launcher_foreground, et le type de ressource sur Image.

Passez ensuite à l'onglet Calque d'arrière-plan de l'interface. Conservez les valeurs par défaut. Cliquez sur l'icône de dossier Path (Chemin d'accès).
Recherchez l'emplacement du fichier ic_launcher_background.xml que vous venez de télécharger. Cliquez sur Open (Ouvrir).

L'aperçu devrait se mettre à jour lorsque vous sélectionnerez les nouveaux fichiers de ressources. Voici ce à quoi la vue devrait ressembler avec les nouveaux calques de premier plan et d'arrière-plan.

En représentant l'icône d'application sur deux calques, les fabricants d'appareils (également appelés fabricants d'équipement d'origine ou, pour faire court, OEM) peuvent créer différentes formes en fonction de l'appareil Android, comme illustré dans l'aperçu ci-dessus. L'OEM fournit un masque qui s'applique à toutes les icônes d'application de l'appareil.

Ce masque s'applique au-dessus des calques de premier plan et d'arrière-plan de l'icône d'application. Exemple de masque circulaire et de masque carré ci-dessous.

Lorsqu'un masque circulaire est appliqué aux deux calques de l'icône d'application, une icône circulaire avec un fond quadrillé bleu contenant un Android (image de gauche ci-dessus) s'affiche. Vous pouvez également appliquer un masque carré pour générer l'icône d'application en haut à droite.

Le fait d'avoir deux calques permet également d'obtenir des effets visuels intéressants, car ces ils peuvent se déplacer indépendamment l'un de l'autre ou être mis à l'échelle. Pour obtenir des exemples amusants d'effets visuels, consultez les considérations liées à la conception dans cet article de blog. Vous ne pouvez pas deviner de quel appareil votre utilisateur dispose ni quel masque l'OEM appliquera à votre icône. Vous devez donc configurer votre icône adaptative de sorte que les informations importantes ne soient pas tronquées.

Assurez-vous que le contenu principal du calque de premier plan (l'icône représentant une cloche de service, dans le cas présent) se trouve dans la zone de sûreté et qu'il n'est pas rogné par les différentes formes de masque. Si le contenu important est tronqué ou paraît trop petit, vous pouvez utiliser le curseur Resize (Redimensionner) sous la section Scaling (Mise à l'échelle) de chaque calque. Dans ce cas, aucun redimensionnement n'est nécessaire. Vous pouvez donc le laisser à 100 %.

Cliquez sur Suivant.
Cette étape consiste à confirmer le chemin d'accès à l'icône. Vous pouvez cliquer sur chaque fichier pour en afficher un aperçu. Un avertissement apparaît en bas de l'écran pour vous informer que certains fichiers existants seront écrasés (en rouge). Ce n'est pas grave, car ces anciens fichiers concernent l'ancienne icône d'application.

Conservez les valeurs par défaut, puis cliquez sur Finish (Terminer).
Vérifiez que tous les éléments générés semblent corrects dans les dossiers mipmap. Exemples :

Bien joué ! Vous allez maintenant effectuer une autre modification.

Déplacer des fichiers drawable vectoriels dans le répertoire -v26

Selon le SDK minimal de votre application, vous remarquerez peut-être que l'élément en arrière-plan se trouve dans le dossier drawable-v24, tandis que l'élément de premier plan se trouve dans le dossier drawable. Cela est dû au fait que l'élément en arrière-plan contient un dégradé, disponible à partir de la version 7.0 d'Android (également appelée version 24 de l'API, d'où le qualificatif de ressource -v24). L'élément de premier plan ne contient pas de dégradé. Vous pouvez donc le placer dans le dossier drawable de base.

Au lieu d'avoir les éléments de premier plan et d'arrière-plan dans deux dossiers drawable distincts, déplacez les deux fichiers drawable vectoriels dans un répertoire de ressources -v26. Étant donné que ces éléments ne sont utilisés que pour les icônes adaptatives, ces deux drawables ne sont nécessaires que sur l'API 26 ou une version ultérieure. Cette structure de dossiers permet de trouver et de gérer plus facilement les fichiers d'icônes adaptatives.

drawable-anydpi-v26
   ic_launcher_background.xml
   ic_launcher_foreground.xml
mipmap-anydpi-v26
   ic_launcher.xml
   ic_launcher_round.xml

Commencez par créer le répertoire drawable-anydpi-v26. Effectuez un clic droit sur le dossier res. Sélectionnez New > Android Resource Directory (Nouveau > Répertoire de ressources Android).
La boîte de dialogue New Resource Directory (Nouveau répertoire de ressources) s'affiche. Sélectionnez les options suivantes :

Nom du répertoire : drawable-anydpi-v26

Type de ressource : drawable (sélectionnez l'option dans le menu déroulant)

Source set (Ensemble de sources) : "main" (conservez la valeur par défaut)

Cliquez sur OK. Dans la vue Project (Projet), vérifiez que le répertoire de ressources res > drawable-anydpi-v26 a été créé.

Effectuez un clic gauche sur le fichier ic_launcher_foreground.xml et faites-le glisser du dossier drawable vers le dossier drawable-anydpi-v26. Rappelez-vous que le fait de placer une ressource dans un répertoire "dpi" indique qu'elle peut s'adapter à n'importe quelle densité.
Effectuez un clic gauche sur ic_launcher_background.xml, puis faites-le glisser depuis le dossier drawable-v24 vers le dossier drawable-anydpi-v26.
Supprimez le dossier drawable-v24 s'il est vide. Effectuez un clic droit sur le dossier, puis sélectionnez Delete (Supprimer).
Cliquez sur tous les fichiers drawable et mipmap de votre projet. Vérifiez que l'aperçu de ces icônes est correct.

Tester votre application

Vérifiez que votre nouvelle icône d'application s'affiche. Exécutez l'application sur votre appareil (émulateur ou appareil physique).
Appuyez sur le bouton d'accueil de votre appareil.
Balayez l'écran vers le haut pour afficher la liste de toutes les applications.
Recherchez l'application que vous venez de mettre à jour. Vous devriez voir la nouvelle icône d'application.

Remarque : Selon le modèle de votre appareil, vous verrez peut-être une icône de lanceur de forme différente. Néanmoins, il devrait afficher le calque de premier plan au-dessus du calque d'arrière-plan. Un type de masque devrait également être appliqué.

Félicitations ! La nouvelle icône d'application a fière allure.

Icônes adaptatives et anciennes icônes de lanceur

Maintenant que votre icône adaptative fonctionne comme souhaité, vous vous demandez peut-être pourquoi vous ne pouvez pas supprimer toutes les images bitmap d'icône d'application. Vous avez besoin de ces fichiers pour que l'icône d'application s'affiche en haute qualité dans les anciennes versions d'Android. On parle alors de rétrocompatibilité.

Sur les appareils équipés d'Android 8.0 ou version ultérieure (API version 26 ou ultérieure) :

Vous pouvez utiliser des icônes adaptatives (combinaison de drawable vectoriel au premier plan, drawable vectoriel en arrière-plan avec application du masque d'un OEM). Voici les fichiers pertinents pour votre projet :

res/drawable-anydpi-v26/ic_launcher_background.xml
res/drawable-anydpi-v26/ic_launcher_foreground.xml
res/mipmap-anydpi-v26/ic_launcher.xml
res/mipmap-anydpi-v26/ic_launcher_round.xml

Sur les appareils exécutant une version antérieure à Android 8.0 (mais supérieure au niveau d'API minimal requis) :

Les anciennes icônes de lanceur sont utilisées (les images bitmap se trouvent dans les dossiers mipmap des différents niveaux de densité). Voici les fichiers pertinents pour votre projet :

res/mipmap-mdpi/ic_launcher.png
res/mipmap-mdpi/ic_launcher_round.png
res/mipmap-hdpi/ic_launcher.png
res/mipmap-hdpi/ic_launcher_round.png
res/mipmap-xhdpi/ic_launcher.png
res/mipmap-xhdpi/ic_launcher_round.png
res/mipmap-xxdpi/ic_launcher.png
res/mipmap-xxdpi/ic_launcher_round.png
res/mipmap-xxxdpi/ic_launcher.png
res/mipmap-xxxdpi/ic_launcher_round.png

En résumé, Android utilise les images bitmap pour les anciens appareils qui ne fonctionnent pas avec les icônes adaptatives.

Félicitations, vous avez terminé toutes les étapes de modification d'une icône d'application.

7. Code de solution

Vous trouverez ci-dessous le code de solution de cet atelier de programmation.

res/mipmap-anydpi-v26/ic_launcher.xml

<?xml version="1.0" encoding="utf-8"?>
<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
    <background android:drawable="@drawable/ic_launcher_background" />
    <foreground android:drawable="@drawable/ic_launcher_foreground" />
</adaptive-icon>

res/mipmap-anydpi-v26/ic_launcher_round.xml

<?xml version="1.0" encoding="utf-8"?>
<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
    <background android:drawable="@drawable/ic_launcher_background" />
    <foreground android:drawable="@drawable/ic_launcher_foreground" />
</adaptive-icon>

res/drawable-anydpi-v26/ic_launcher_background.xml

<vector xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:aapt="http://schemas.android.com/aapt"
    android:width="108dp"
    android:height="108dp"
    android:viewportWidth="108"
    android:viewportHeight="108">
  <path
      android:pathData="M0,0h108v108h-108z">
    <aapt:attr name="android:fillColor">
      <gradient
          android:startY="-1.0078"
          android:startX="54"
          android:endY="106.9922"
          android:endX="54"
          android:type="linear">
        <item android:offset="0" android:color="#FF12C26D"/>
        <item android:offset="1" android:color="#FF0F9453"/>
      </gradient>
    </aapt:attr>
  </path>
</vector>

res/drawable-anydpi-v26/ic_launcher_foreground.xml

<vector xmlns:android="http://schemas.android.com/apk/res/android"
    android:width="108dp"
    android:height="108dp"
    android:viewportWidth="108"
    android:viewportHeight="108">
  <path
      android:pathData="M38.19,65.92L69.32,65.92a1.2,1.2 0,0 0,1.2 -1.2,0.89 0.89,0 0,0 0,-0.23 17,17 0,0 0,-33.25 0,1.18 1.18,0 0,0 0.9,1.42ZM74.53,69.05a0.85,0.85 0,0 0,-0.78 -0.84L34,68.21a0.85,0.85 0,0 0,-0.77 0.84v2.82a0.84,0.84 0,0 0,0.77 0.86L73.78,72.73a0.85,0.85 0,0 0,0.77 -0.86L74.55,70.65C74.55,70.24 74.56,69.58 74.53,69.05ZM52.08,49h3.59a1.86,1.86 0,0 0,0 -3.72L52.08,45.28a1.86,1.86 0,0 0,0 3.72ZM53.87,39.81a1.19,1.19 0,0 0,1.19 -1.19L55.06,32.87a1.19,1.19 0,0 0,-2.38 0v5.71a1.19,1.19 0,0 0,1.19 1.19h0ZM61.69,41l4.62,-3.35a1.19,1.19 0,1 0,-1.4 -1.93L60.29,39A1.2,1.2 0,0 0,60 40.67a1.18,1.18 0,0 0,1.66 0.26ZM41.69,37.65L46.31,41a1.2,1.2 0,0 0,1.35 -2L43,35.66a1.19,1.19 0,0 0,-1.66 0.26,1.2 1.2,0 0,0 0.3,1.67Z"
      android:fillColor="#FFFFFF"/>
</vector>

Les images bitmap devraient également avoir été générées automatiquement par Android Studio aux emplacements suivants :

res/mipmap-mdpi/ic_launcher.png
res/mipmap-mdpi/ic_launcher_round.png
res/mipmap-hdpi/ic_launcher.png
res/mipmap-hdpi/ic_launcher_round.png
res/mipmap-xhdpi/ic_launcher.png
res/mipmap-xhdpi/ic_launcher_round.png
res/mipmap-xxdpi/ic_launcher.png
res/mipmap-xxdpi/ic_launcher_round.png
res/mipmap-xxxdpi/ic_launcher.png
res/mipmap-xxxdpi/ic_launcher_round.png

8. Résumé

Les fichiers d'icône d'application ont été placés dans les répertoires de ressources mipmap.
Fournissez différentes versions de l'image bitmap d'une icône d'application dans chaque niveau de densité (mdpi, hdpi, xhdpi, xxhdpi, xxxhdpi) pour assurer la rétrocompatibilité avec les anciennes versions d'Android.
Ajoutez des qualificateurs de ressources aux répertoires de ressources pour spécifier les ressources à utiliser sur les appareils disposant d'une certaine configuration (par exemple, v26).
Les drawables vectoriels sont l'implémentation Android des graphiques vectoriel. Ils sont définis en XML sous la forme d'un ensemble de points, de lignes et de courbes, ainsi que d'informations de couleur associées. Vous pouvez mettre à l'échelle la taille des drawables vectoriels sans perdre en qualité.
Les icônes adaptatives ont été introduites dans l'API 26 de la plate-forme Android. Elles sont composées d'un calque de premier plan et d'un calque d'arrière-plan qui respectent des exigences spécifiques, afin que l'icône d'application soit de haute qualité sur toute une gamme d'appareils utilisant des masques d'OEM différents.
Image Asset Studio dans Android Studio vous permet de créer des icônes adaptatives pour votre application.