Dans ce chapitre, nous aborderons les sujets suivants:
► Définir et gonfler une mise en page
► Utilisation de RelativeLayout
► Utilisation de LinearLayout
► Création de tables - TableLayout et GridLayout
► Utilisation de ListView, GridView et d'adaptateurs
► Modification des propriétés de disposition pendant l'exécution
► Optimisation des mises en page avec la visionneuse de la hiérarchie
Dans Android, l'interface utilisateur est définie dans une mise en page. Une mise en page peut être déclarée en XML ou créée dynamiquement dans le code. (Il est recommandé de déclarer la mise en page en XML plutôt qu'en code afin de conserver la couche de présentation distincte de la couche d'implémentation.) Une mise en page peut définir un objet Listitem individuel, un fragment ou même toute l'activité. Les fichiers de mise en page sont stockés dans le dossier / res / layout et référencés dans le code avec l'identificateur suivant: R.layout. <Filename_without_extension>.
Android fournit une variété utile de classes de mise en page qui contiennent et organisent des éléments individuels d'une activité (tels que des boutons, des cases à cocher et d'autres vues). L'objet ViewGroup est un objet conteneur qui sert de classe de base pour la famille de classes Layout d'Android. Les vues placées dans une mise en page forment une hiérarchie, la mise en page la plus haute étant le parent.
Android fournit plusieurs types de mise en page intégrés conçus pour des objectifs spécifiques, tels que RelativeLayout, qui permet de positionner les vues par rapport à d'autres éléments. LinearLayout peut empiler les Vues ou les aligner horizontalement, selon l'orientation spécifiée. Le TableLayout peut être utilisé pour disposer une grille de Vues. Dans différentes dispositions, nous pouvons également justifier les Vues avec Gravité et fournir une taille proportionnelle avec le contrôle du poids. Les dispositions et viewGroups peuvent être imbriqués les uns dans les autres pour créer des configurations complexes. Plus d'une douzaine d'objets Layout différents sont fournis pour la gestion des widgets, des listes, des tableaux, des galeries et d'autres formats d'affichage. De plus, vous pouvez toujours dériver des classes de base pour créer vos propres dispositions personnalisées.
Avant de pouvoir commencer à optimiser vos mises en page, il est utile de comprendre le processus de mise en page Android. Enflatant une mise en page, commence lorsque l'activité apparaît pour la première fois. Trois étapes se produisent:
► Mesurer: C'est ici que les vues déterminent leur taille, en commençant par le parent et en travaillant avec tous les enfants. Le parent peut devoir appeler ses enfants plusieurs fois pour calculer la taille finale.
► Mise en page: C'est là que le parent détermine la position de ses enfants
► Dessiner: C'est là que les vues sont réellement rendues
Ce processus commence avec le parent, qui parcourt ensuite tous ses enfants. Ces enfants parcourent leurs enfants. Cela crée l'arbre de disposition, le parent devenant le nœud racine de l'arbre.
Hierarchy Viewer est un outil inclus avec le SDK Android pour l'inspection des mises en page. Il montre graphiquement l'arbre de disposition ainsi que les résultats de synchronisation pour chaque vue / nœud. En examinant la disposition de l'arbre et le calendrier; vous pouvez rechercher une conception inefficace et des goulots d'étranglement. Armé de cette information, vous êtes en mesure d'optimiser vos mises en page.
Pour cette recette, nous allons utiliser Hierarchy Viewer pour inspecter l'exemple de disposition donné dans la recette Using RelativeLayout.
Se préparer
Dans la section Il y a plus ... de la recette Using RelativeLayout, un exemple LinearLayout a été montré pour mettre en évidence la différence entre les mises en page. Le commentaire a été fait en indiquant que LinearLayout nécessitait une mise en page imbriquée. Nous allons créer un nouveau projet appelé OptimizingLayouts en utilisant l'exemple LinearLayout. Nous utiliserons ensuite Hierarchy Viewer pour inspecter la mise en page. Nous aurons besoin d'un appareil Android enraciné ou de l'émulateur pour cette recette.
Hierarchy Viewer se connecte uniquement aux périphériques enracinés, tels qu'un émulateur.
Comment faire...
1. Ouvrez le projet OptimizingLayouts dans Android Studio. Exécutez le projet sur votre appareil enraciné (ou émulateur) et assurez-vous que l'écran est visible (déverrouiller si nécessaire).
2. Dans Android Studio, démarrez Android Device Monitor en accédant à l'option de menu suivante: Outils | Android | Moniteur de périphérique Android.
3. Dans Android Device Monitor, passez à la vue Vue hiérarchique en accédant à Fenêtre | Open Perspective ... ceci ouvrira la boîte de dialogue suivante:
4. Maintenant, cliquez sur Hierarchy Viewer et sur OK.
5. Dans la section Windows sur la gauche se trouve la liste des périphériques avec les processus en cours d'exécution. Cliquez sur le processus OptimizingLayouts pour inspecter la mise en page.
6. Voir la représentation graphique de cette activité dans la section TreeView (dans le volet central, qui occupe la plus grande partie de la perspective Hierarch Viewer).
LinearLayout LinearLayout TextView
@ 1236adb @ e40a851 @ 6e3d9b7
0 0 0
Comment ça marche...
La section Tree Layout affiche une hiérarchie graphique des vues qui composent cette mise en page, ainsi que les heures de mise en page. (Malheureusement pour cette démonstration, les temps de rendu sont trop rapides pour les références visuelles de codage couleur.) Ce qui est important pour cet exemple, c'est que LinearLayouts imbriqué
montré précédemment. (Cela vaut la peine de prendre le temps d'explorer les autres vues qui composent cette mise en page afin que vous puissiez voir ce que Android fait pour nous dans les coulisses.)
Comme déjà mentionné dans l'exemple RelativeLayout, la solution est de repenser cette disposition en utilisant le RelativeLayout. Idéalement, nous voulons une mise en page plus large et plus plate, plutôt que des mises en page profondément imbriquées pour réduire le nombre d'itérations requises lors de l'étape de dimensionnement.
À des fins de synchronisation, c'est évidemment un exemple trivial, mais même cet exemple peut avoir un impact. Imaginez l'utilisateur feuilletant une liste avec des milliers d'éléments basés sur cette mise en page inefficace. Si vous rencontrez le bégaiement pendant le défilement, vos étapes d'optimisation peuvent commencer par examiner la disposition dans Hierarchy Viewer.
Il y a plus...
Lint est un autre outil inclus avec le SDK Android avec prise en charge intégrée par Android Studio. Par défaut, vous utilisez déjà Lint pour vérifier votre code à la recherche de problèmes tels que les appels d'API obsolètes, les appels d'API non pris en charge pour le niveau d'API cible, les problèmes de sécurité, etc. Pour les problèmes d'optimisation de la mise en page, certaines des conditions que Lint vérifie automatiquement sont les suivantes:
► Layouts profonds - le maximum par défaut est de 10 niveaux
► Poids imbriqués, qui sont mauvais pour la performance
► Parent inutile
► Feuille inutile
Si vous vérifiez l'avertissement Lint dans Android Studio pour cette disposition, vous verrez l'avertissement suivant sur le deuxième élément LinearLayout:
> activity_main.xml
c MainActivity.java x K? activity_main.xml x
http://schemas.android.com/apk/res/android" "><? xml version = "l.0" encoding = "utf-8"?> c <LinearLayout xmlns: android = "http://schemas.android.com/apk/res/android"
android: orientation = "horizontal" android: layout_width = "match_parent" android: layout_height = "match_parent" android: gravity = "centre">
{4Th
Le ViewStub peut également être utilisé pour optimiser une mise en page. Pensez à ViewStub comme une "charge paresseuse" pour votre mise en page. La disposition dans le ViewStub ne se déploiera pas tant que cela n'est pas nécessaire, ce qui réduit les vues nécessaires pour gonfler. La mise en page sera plus rapide et utilisera moins de mémoire. C'est une excellente façon de disposer de fonctionnalités rarement utilisées, comme une fonction d'impression, disponible en cas de besoin, mais qui n'occupe pas la mémoire lorsqu'elle n'est pas nécessaire. Voici un exemple de ViewStub:
<ViewStub
android: id = "@ + id / viewStubPrint"
android: inflatedId = "@ id / print"
android: layout = "@ layout / print"
android: layout_width = "wrap_content"
android: layout_height = "wrap_content" />
Il y a deux façons de gonfler réellement le ViewStub:
► Réglez le paramètre de visibilité de ViewStub sur VISIBLE:
((ViewStub) findViewById (R.id.viewStubPrint)). setVisibility (View.VISIBLE);
► Appelez la méthode inflate () sur ViewStub:
Voir la vue = ((ViewStub) findViewById (R.id.viewStubPrint)). Inflate ();
Une fois le ViewStub gonflé, l'identifiant ViewStub sera supprimé de la mise en page et remplacé par l'ID gonflé.
Dans le développement Android, il est généralement préférable de définir l'interface utilisateur avec XML et le code de l'application en Java, en conservant le code de l'interface utilisateur distinct du code de l'application. Il y a des moments où il est beaucoup plus facile ou plus efficace de modifier (ou même de construire) l'interface utilisateur à partir du code Java. Heureusement, cela est facilement pris en charge dans Android.
Nous avons vu un petit exemple de modification de la disposition du code dans la recette précédente, où nous avons défini le nombre de colonnes GridView à afficher dans le code. Dans cette recette, nous allons obtenir une référence à l'objet LayoutParams pour modifier la marge pendant l'exécution.
Se préparer
Ici, nous allons configurer une mise en page simple avec XML et utiliser un objet LinearLayout.LayoutParams pour modifier les marges d'une vue pendant l'exécution.
Comment faire....
1. Ouvrez le fichier activity_main.xml et modifiez la disposition de RelativeLayout à LinearLayout. Cela ressemblera à ceci:
http://schemas.android.com/apk/res/ android" "><LinearLayout xmlns: android = "http://schemas.android.com/apk/res/ android"
http://schemas.android.com/tools" ">xmlns: tools = "http://schemas.android.com/tools"
android: layout_width = "match_parent"
android: layout_height = "match_parent">
</ LinearLayout>
2. Ajoutez un TextView et incluez un ID comme suit:
android: id = "@ + id / textView"
3. Ajouter un bouton et inclure un ID comme suit:
android: id = "@ + id / bouton"
4. Ouvrez MainActivity.java et ajoutez le code suivant à la méthode onCreate () pour configurer un écouteur d'événement onClick:
Bouton bouton = (Bouton) findViewByld (R.id.button); button.setOnClickListener (new View.OnClickListener () {
@Passer outre
public void onClick (Voir la vue) {
((TextView) findViewById (
R.id.textView)). SetText ("Changé à l'exécution!"); LinearLayout.LayoutParams params = (LinearLayout.
LayoutParams) view.getLayoutParams (); params.leftMargin + = 5;
5. Exécutez le programme sur un périphérique ou un émulateur.
Comment ça marche...
Chaque vue (et donc ViewGroup) est associée à un ensemble de paramètres de disposition. En particulier, toutes les vues ont des paramètres pour informer leur parent de la hauteur et de la largeur désirées. Ceux-ci sont définis avec les paramètres layout_height et layout_width. Nous pouvons accéder à ces informations de disposition à partir du code avec la méthode getLayoutParams (). Les informations de disposition comprennent la hauteur, la largeur, les marges et tous les paramètres spécifiques à la classe.
Dans cet exemple, nous avons déplacé le bouton à chaque clic en obtenant le bouton LayoutParams et en changeant la marge.
Lorsque vous devez créer une table dans votre interface utilisateur, Android propose deux options de mise en page pratiques: TableLayout (avec TableRow) et GridLayout (ajoutées dans l'API 14). Les deux options de disposition peuvent créer des tableaux similaires, mais chacun utilisant une approche différente. Avec TableLayout, les lignes et les colonnes sont ajoutées dynamiquement lorsque vous générez la table. Avec GridLayout, les tailles de ligne et de colonne sont définies dans la définition de la mise en page.
Une autre option de mise en page courante est LinearLayout, qui organise les vues enfant dans une seule colonne ou une seule rangée, en fonction de l'orientation spécifiée. L'orientation par défaut (si elle n'est pas spécifiée) est verticale, ce qui aligne les vues dans une seule colonne.
LinearLayout possède une fonctionnalité clé non proposée dans RelativeLayout: l'attribut weight. Nous pouvons spécifier un paramètre layout_weight lors de la définition d'une vue pour autoriser la taille dynamique de la vue en fonction de l'espace disponible. Les options incluent une vue remplissant tout l'espace restant (si une vue a un poids plus élevé), ayant plusieurs vues dans l'espace donné (si tous ont le même poids), ou espaçant proportionnellement les vues par leur poids.
Nous allons créer un LinearLayout avec trois vues EditText pour montrer comment l'attribut weight peut être utilisé. Pour cet exemple, nous allons utiliser trois vues EditText: une pour entrer un paramètre d'adresse, une autre pour entrer un sujet et la troisième pour entrer un message.
Les vues À et Sujet seront chacune une ligne, l'espace restant étant donné à la vue des messages.
Se préparer
Créez un nouveau projet et appelez-le LinearLayout. Nous allons remplacer le défaut
RelativeLayout créé dans activity_main.xml avec un LinearLayout.
Comment faire...
1. Ouvrez le fichier res / layout / activity_main.xml et remplacez-le comme suit:
2. Exécutez le code ou affichez la disposition dans l'onglet Conception.
Comment ça marche...
Lorsque vous utilisez l'orientation verticale avec LinearLayout, les vues enfants sont créées dans une seule colonne (empilées les unes sur les autres). Les deux premières vues utilisent l'attribut android: layout_haut = "wrap_content", en leur donnant une seule ligne chacune. editTextMessage utilise les éléments suivants pour spécifier la hauteur:
android: layout_height = "0dp"
android: layout_weight = "1"
Lorsque vous utilisez le LinearLayout, il indique à Android de calculer la hauteur en fonction du poids. Un poids de 0 (valeur par défaut si non spécifié) indique que la vue ne doit pas être développée. Dans cet exemple, editTextMessage est la seule vue définie avec un poids. Elle sera donc développée seule pour remplir tout espace restant dans la disposition parente.
Lorsque vous utilisez l'orientation horizontale, spécifiez android: layout_haut = "0dp" (avec le poids) pour qu'Android calcule la largeur.
Il peut être utile de penser à l'attribut weight en pourcentage. Dans ce cas, le poids total défini est 1, donc cette vue obtient 100% de l'espace restant. Si nous attribuons un poids de 1 à une autre vue, le total sera de 2, donc cette vue obtiendrait 50% de l'espace. Essayez d'ajouter un poids à l'une des autres vues (assurez-vous de changer la hauteur à 0dp ainsi) pour le voir en action.
Si vous avez ajouté un poids à l'une (ou aux deux) des autres vues, avez-vous remarqué la position du texte? Sans spécifier de valeur pour la gravité, le texte reste simplement au centre de l'espace de vue. Le paramètre editTextMessage spécifie: android: gravity = "top", qui force le texte en haut de la vue.
Il y a plus...
Les options d'attributs multiples peuvent être combinées au moyen d'un OU au niveau du bit. (Java utilise le caractère de tuyau (|) pour OU). Par exemple, nous pourrions combiner deux options de gravité à la fois pour aligner le haut du parent et le centre dans l'espace disponible:
android: layout_gravity = "haut | centre"
Il est à noter que les balises layout_gravity et gravity ne sont pas la même chose. Lorsque layout_gravity dicte l'emplacement d'une vue dans son parent, la gravité contrôle le positionnement du contenu dans une vue, par exemple, l'alignement du texte sur un bouton.
Voir également
► La recette précédente, Utilisation du RelativeLayout