Layouts

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.

Aucune mise en page n'est meilleure, c'est juste une question d'utilisation de la meilleure mise en page pour vos besoins. Nous allons créer une grille 3 x 3 en utilisant chaque mise en page pour donner une comparaison, car vous pourriez facilement vous retrouver en utilisant les deux mises en page, même au sein de la même application.

Se préparer
Pour rester concentré sur les dispositions et offrir une comparaison plus facile, nous allons créer deux applications distinctes pour cette recette. Créez deux nouveaux projets Android, le premier appelé TableLayout et l'autre appelé GridLayout.
Comment faire...
1. À partir du projet TableLayout, ouvrez activity_main.xml. Changez la disposition racine à TableLayout.
2. Ajoutez trois TableRows avec trois ensembles de TextViews à chaque TableRow pour créer une matrice 3 x 3. À des fins de démonstration, les colonnes sont étiquetées A-C et les lignes 1-3, de sorte que la première ligne de TextViews sera A1, B1 et C1. Le résultat final ressemblera à ceci:
<TableLayout
http://schemas.android.com/apk/res/android" ">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">
<TableRow
android: layout_width = "match_parent"
android: layout_height = "match_parent">
<TextView
android: layout_width = "wrap_content" android: layout_height = "wrap_content" android: texte = "A1" android: id = "@ + id / textView1" /> <TextView
android: layout_width = "wrap_content" android: layout_height = "wrap_content" android: texte = "B1" android: id = "@ + id / textView2" /> <TextView
android: layout_width = "wrap_content" android: layout_height = "wrap_content" android: texte = "C1" android: id = "@ + id / textView3" /> </ TableRow>
<TableRow
android: layout_width = "match_parent"
android: layout_height = "match_parent">
<TextView
android: layout_width = "wrap_content" android: layout_height = "wrap_content" android: texte = "A2" android: id = "@ + id / textView4" /> <TextView
android: layout_width = "wrap_content" android: layout_height = "wrap_content" android: texte = "B2" android: id = "@ + id / textView5" /> <TextView
android: layout_width = "wrap_content" android: layout_height = "wrap_content" android: texte = "C2" android: id = "@ + id / textView6" /> </ TableRow>
<TableRow
android: layout_width = "match_parent"
android: layout_height = "match_parent">
<TextView
android: layout_width = "wrap_content" android: layout_height = "wrap_content" android: texte = "A3" android: id = "@ + id / textView7" />
 <TextView
android: layout_width = "wrap_content" android: layout_height = "wrap_content" android: texte = "B3" android: id = "@ + id / textView8" />
<TextView
android: layout_width = "wrap_content" android: layout_height = "wrap_content" android: texte = "C3" android: id = "@ + id / textView9" />
</ TableRow>
</ TableLayout>
3. Maintenant, ouvrez le projet GridLayout pour modifier activity_main.xml. Changez la disposition racine à GridLayout. Ajoutez les attributs columnCount = 3 et rowCount = 3 au
GridLayout élément.
4. Maintenant, ajoutez neuf TextViews à GridLayout. Nous utiliserons le même texte que le précédent TableLayout pour une comparaison cohérente. Étant donné que GridView n'utilise pas TableRows, les trois premiers TextView sont dans la ligne 1, les trois suivants sont dans la ligne 2 et ainsi de suite. Le résultat final ressemblera à ceci:
<GridLayout
http://schemas.android.com/apk/res/android" ">xmlns: android = "http://schemas.android.com/apk/res/android"
android: layout_width = "match_parent"
android: layout_height = "match_parent"
android: columnCount = "3"
android: rowCount = "3">
<TextView
android: layout_width = "wrap_content" android: layout_height = "wrap_content" android: texte = "A1" android: id = "@ + id / textView1" />
<TextView
android: layout_width = "wrap_content" android: layout_height = "wrap_content" android: texte = "B1" android: id = "@ + id / textView2" />
<TextView
android: layout_width = "wrap_content" android: layout_height = "wrap_content" android: texte = "C1" android: id = "@ + id / textView3" />
<TextView
android: layout_width = "wrap_content"
android: layout_height = "wrap_content"
{3T | -

 
android: text = "A2" android: id = "@ + id / textView4" />
<TextView
android: layout_width = "wrap_content" android: layout_height = "wrap_content" android: texte = "B2" android: id = "@ + id / textView5" />
<TextView
android: layout_width = "wrap_content" android: layout_height = "wrap_content" android: texte = "C2" android: id = "@ + id / textView6" />
<TextView
android: layout_width = "wrap_content" android: layout_height = "wrap_content" android: texte = "A3" android: id = "@ + id / textView7" />
<TextView
android: layout_width = "wrap_content" android: layout_height = "wrap_content" android: texte = "B3" android: id = "@ + id / textView8" />
<TextView
android: layout_width = "wrap_content" android: layout_height = "wrap_content" android: texte = "C3" android: id = "@ + id / textView9" />
</ GridLayout>
5. Vous pouvez exécuter l'application ou utiliser l'onglet Conception pour voir les résultats.
Comment ça marche...
Comme vous pouvez le voir lors de la visualisation des tableaux créés, les tableaux se ressemblent à l'écran. La principale différence est le code pour les créer.
Dans le XML TableLayout, chaque ligne est ajoutée à la table en utilisant un TableRow. Chaque vue devient une colonne. Ce n'est pas une exigence car les cellules peuvent être ignorées ou laissées vides.
(Voir comment spécifier l'emplacement de la cellule dans un TableRow dans la section suivante.)
Le GridLayout utilise l'approche inverse. Le nombre de lignes et de colonnes est spécifié lors de la création de la table. Nous n'avons pas besoin de spécifier les informations de ligne ou de colonne (bien que nous puissions, discuté comme suit). Android ajoutera automatiquement chaque vue aux cellules dans l'ordre.
Il y a plus...
Tout d'abord, voyons plus de similitudes entre les mises en page. Les deux dispositions ont la capacité d'étirer les colonnes pour utiliser l'espace d'écran restant. Pour TableLayout, ajoutez l'attribut suivant à la déclaration xml:
android: stretchColumns = "1"
stretchColumns spécifie l'index (basé sur zéro) des colonnes à étirer. (android: shrinkColumns est un index basé sur zéro des colonnes qui peuvent rétrécir, ainsi la table peut s'adapter à l'écran.)
Pour obtenir le même effet avec GridLayout, ajoutez l'attribut suivant à toutes les vues de la colonne B (textView2, textView5 et textView8):
android: layout_columnWeight = "1"
Toutes les cellules d'une colonne donnée doivent définir le poids ou ne pas s'étirer.
Maintenant, regardons quelques-unes des différences, car c'est vraiment la clé pour déterminer quelle mise en page utiliser pour une tâche donnée. La première chose à noter est de savoir comment les colonnes et les lignes sont réellement définies.
Dans le TableLayout, les lignes sont spécifiquement définies, en utilisant un TableRow. (Android déterminera le nombre de colonnes dans la table en fonction de la ligne contenant le plus de cellules.) Utilisez l'attribut android: layoutColumn lors de la définition de la vue pour spécifier la colonne.
En revanche, avec GridLayout, les nombres de lignes et de colonnes sont spécifiés lors de la définition de la table (en utilisant columnCount et rowCount comme indiqué précédemment).
Dans l'exemple précédent, nous avons simplement ajouté TextViews à GridLayout et laissé le système les positionner automatiquement. Nous pouvons modifier ce comportement en spécifiant la position de ligne et de colonne lors de la définition de la vue, par exemple:
android: layout_row = "2"
android: layout_column = "2"
Android incrémente automatiquement le compteur de cellules après l'ajout de chaque vue, de sorte que la vue suivante doit également spécifier la ligne et la colonne, sinon vous risquez de ne pas obtenir le résultat souhaité.
Comme le LinearLayout montré dans la recette LinearLayout, le GridLayout offre également l'attribut d'orientation de soutenir horizontal (le défaut) et vertical. L'orientation détermine comment les cellules sont placées. (L'horizontale remplit d'abord les colonnes, puis descend à la ligne suivante, tandis que la verticale remplit la première colonne de chaque rangée, puis la colonne suivante.)
{Hh
ListView et GridView sont tous les deux des descendants de ViewGroup, mais ils sont plus utilisés comme une vue car ils sont pilotés par les données. En d'autres termes, plutôt que de définir toutes les vues possibles qui pourraient remplir un ListView (ou GridView) au moment de la conception, le contenu est créé dynamiquement à partir des données transmises à la vue. (La disposition de Listitem peut être créée au moment du design pour contrôler l'apparence des données pendant l'exécution.)
Par exemple, si vous deviez présenter une liste de pays à un utilisateur, vous pouvez créer un LinearLayout et ajouter un bouton pour chaque pays. Il y a plusieurs problèmes avec cette approche: déterminer les pays disponibles, maintenir la liste des boutons à jour, avoir suffisamment d'espace pour tous les pays, etc. Sinon, vous pouvez créer une liste de pays pour remplir un ListView, qui créera alors un bouton pour chaque entrée.
Nous allons créer un exemple, en utilisant la seconde approche, pour remplir un ListView à partir d'un tableau de noms de pays.

Se préparer
Créez un nouveau projet dans Android Studio et appelez-le ListView. La classe ActivityMain par défaut étend la classe Activity. Nous allons le changer pour étendre la classe ListActivity à la place. Nous allons ensuite créer une liste de chaînes simple et la lier à ListView, pour dériver les boutons lors de l'exécution.

Comment faire...
1. Ouvrez le fichier MainActivity.java et modifiez la déclaration de base afin qu'elle s'étende
ListActivity au lieu de la classe Activity:
classe publique MainActivity extends ListActivity {
2. Changez onCreate () pour qu'il corresponde à ce qui suit:
void protégé onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState);
String [] countries = new String [] {"Chine", "France", "Allemagne", "Inde", "Russie", "Royaume-Uni",
"États Unis"};
ListAdapter countryAdapter = new
ArrayAdapter <String> (this, android.R.layout. Simple_list_item_1, pays); setListAdapter (countryAdapter);
-C38}
getListView (). setOnItemClickListener (
new AdapterView.OnItemClickListener () {
@Passer outre
void public onItemClick (AdapterView <?> parent, Vue vue, position int, identifiant long) {
String s = ((TextView) view) .getText () + "" + position;
Toast.makeText (getApplicationContext (), s, Toast.LENGTH_SHORT) .show ();
}
}
3. Maintenant, exécutez l'application sur un émulateur ou un périphérique pour voir le ListView rempli.
Comment ça marche...
Nous commençons par créer un tableau simple de noms de pays, puis l'utilisons pour remplir un ListAdapter. Dans cet exemple, nous avons utilisé un ArrayAdapter lors de la construction de ListAdapter, mais Android a également plusieurs autres types d'adaptateurs disponibles. Par exemple, si vos données sont stockées dans une base de données, vous pouvez utiliser CursorAdapter. Si l'un des types prédéfinis ne répond pas à vos besoins, vous pouvez toujours utiliser CustomAdapter.
Nous créons l'adaptateur avec cette ligne de code:
ListAdapter countryAdapter = new ArrayAdapter <String> (this, android.R.layout.simple_list_item_1, pays);
Ici, nous instancions ArrayAdapter en utilisant notre tableau de chaînes (le dernier paramètre). Remarquez le paramètre android.R.layout.simple_list_item_1? Ceci définit la disposition du bouton. Ici, nous utilisons l'une des mises en page fournies par Android, mais nous pouvons créer notre propre mise en page et transmettre notre identifiant à la place.
Une fois que l'adaptateur est prêt, nous le passons à ListView sous-jacent avec l'appel setListAdapter (). (Le ListView sous-jacent provient de l'extension de ListViewActivity.) Enfin, nous implémentons setOnItemClickListener pour afficher un Toast lorsque l'utilisateur appuie sur un bouton (qui représente un pays) dans la liste.
ListViews sont très communs dans Android car ils utilisent efficacement l'espace de l'écran avec une vue défilante, ce qui peut être très pratique sur les petits écrans. La disposition ScrollView offre une approche alternative pour créer un effet de défilement similaire. La principale différence entre les deux approches est que la mise en page ScrollView est entièrement gonflée avant d'être affichée à l'utilisateur, alors que ListView ne fait que gonfler les vues qui seront visibles. Pour des données limitées, cela peut ne pas poser de problème, mais pour les ensembles de données plus volumineux, l'application peut manquer de mémoire avant même que la liste ne s'affiche.
{mb
En outre, puisque la liste est pilotée par un adaptateur de données, les données peuvent facilement être modifiées.
Même dans notre exemple limité, l'ajout d'un nouveau pays à l'écran est aussi simple que l'ajout du nom à la liste des pays. Plus important encore, la liste peut être mise à jour pendant l'exécution pendant que l'utilisateur utilise l'application (par exemple, télécharger une liste mise à jour à partir d'un site Web pour afficher les options en temps réel).

Il y a plus...
La Listview prend également en charge un mode de sélection multiple à l'aide de la méthode setChoiceMode (). Pour le voir en action, ajoutez la ligne de code suivante après setListAdapter ():
getListView (). setChoiceMode (ListView.CHOICE_MODE_MULTIPLE);
Ensuite, modifiez la disposition ListItem de android.R.layout.simple_list_item_1 à android.R.layout.simple_list_item_checked.
Alors que la plupart des applications nécessitant une liste déroulante se tournent vers ListView, Android propose également GridView. Ils sont très similaires dans la fonctionnalité, même en utilisant les mêmes adaptateurs de données. La principale différence est visuelle qui permet plusieurs colonnes. Pour mieux comprendre, changeons l'exemple ListView en GridView.
Pour commencer, nous devons changer MainActivity de nouveau à partir de Activity, au lieu de ListActivity. (Cela annulera l'étape 1 précédente.) Ensuite, remplacez onCreate () avec le code suivant:
void protégé onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState);
GridView gridView = nouveau GridView (this); setContentView (gridView);
String [] countries = new String [] {"Chine", "France",
"Allemagne", "Inde", "Russie", "Royaume-Uni",
"États Unis"};
ListAdapter countryAdapter = new ArrayAdapter <String> (this, android.R.layout.simple_list_item_1, pays); gridView.setAdapter (countryAdapter); gridView.setNumColumns (2); gridView.setOnItemClickListener (new AdapterView.OnItemClickListener () {
@Passer outre
void public onItemClick (AdapterView <?> parent, Vue vue, position int, identifiant long) {
String s = ((TextView) view) .getText () + "" + position;
Toast.makeText (getApplicationContext (), s, Toast.LENGTH_SHORT) .show ();
 }
}
Comme vous pouvez le voir, il y a plus de code d'installation pour le Gridview que pour le ListView. La méthode onCreate () crée un nouveau Gridview et le transmet dans l'appel setContentView (). (Nous avons utilisé cette variante de setContentView, comme indiqué dans Définir et gonfler une mise en page, au lieu de créer une mise en page avec seulement un Gridview, mais le résultat final est le même.)
La classe de base ListViewActivity gère une grande partie de cela, mais la Gridview n'a pas de classe d'activité correspondante à étendre.

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.

  1. <LinearLayout
  2. xmlns: android = "http://schemas.android.com/apk/res/android"
  3. android: orientation = "verticale"
  4. android: layout_width = "match_parent"
  5. android: layout_height = "match_parent">
  6.  
  7. <EditText
  8. android: id = "@+id/editTextTo"
  9. android: layout_width = "match_parent"
  10. android: layout_height = "wrap_content"
  11. android: hint = "À" />
  12.  
  13. <EditText
  14. android: id = "@+id/editTextSubject"
  15. android: layout_width = "match_parent"
  16. android: layout_height = "wrap_content"
  17. android: hint = "Sujet" />
  18.  
  19. <EditText
  20. android: id = "@+id/editTextMessage"
  21. android: layout_width = "match_parent"
  22. android: layout_height = "0dp"
  23. android: layout_weight = "1"
  24. Android: gravité = "top"
  25. android: hint = "Message" />
  26. </ LinearLayout>


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