Introduction

Durant les prochaines semaines, nous

allons nous intéresser aux applications de
gestion d’une liste d’items.

Stockage d’une liste

Affichage d’une liste, adaptateurs
Consultation et édition d’un item
Présentation
Principe général
On veut programmer une application pour afficher et éditer une liste
d’items.

Cette semaine, la liste est stockée dans un tableau type

ArrayList ; Ensuite, ça sera dans une BDD Realm.
L’écran est occupé par un RecyclerView. C’est une vue
spécialisée dans l’affichage de listes quelconques.
Consulter ces explications qui sont très claires et très complètes,
mais qui n’utilisent pas les ViewBindings.
Il y a aussi la documentation Google, assez compliquée, sur les
RecyclerView, et celle là sur les adaptateurs.
Anciennement, on utilisait des ListView, mais ils sont délaissés car
trop peu polyvalents.
Schéma global
Modèle MVC : le contrôleur entre les données et la vue s’appelle un
adaptateur.
Une classe pour représenter les items

Pour commencer, il faut représenter les données :

public class Product {
public String libelle;
public int prix;

Product(String libelle, int prix) {

this.libelle = libelle;
this.prix = prix;
}
}

Lui rajouter tous les accesseurs (getters) et modificateurs (setters)

pour en faire un JavaBean : objet Java simple (POJO) composé de
variables membres privées initialisées par le constructeur, et
d’accesseurs.
Données initiales
Deux solutions pour initialiser la liste avec des items prédéfinis :

Un tableau dans les ressources, voir page 11.

Un tableau constant Java comme ceci :
final Product[] initdata = {
new Product("Prod1", 58),
new Product("Prod2", 201),
new Product("Prod3", 98),
...
};

final signifie constant, initdata ne pourra pas être réaffecté (par

contre, ses cases peuvent être réaffectées).
Copie dans un ArrayList
L’étape suivante consiste à recopier les valeurs initiales dans un
tableau dynamique de type ArrayList<Product> :
private List<Product> liste;

void onCreate(...)
{
...

// copie du tableau initdata dans le ArrayList

liste = new ArrayList<>(Arrays.asList(initdata));
}

NB: Arrays.asList crée une liste non modifiable, c’est pour ça

qu’on la recopie dans un ArrayList.
Rappels sur le container List<type>
C’est un type de données générique, c’est à dire paramétré par le
type des éléments mis entre <. . . > ; ce type doit être un objet.
List<TYPE> liste = new ArrayList<>();

NB: le type entre <> à droite est facultatif.

La variable est du type List (superclasse abstraite) et affectée avec

un ArrayList. La raison est qu’il faut de préférence toujours
employer le type le plus général qui possède les méthodes voulues.
Mais quand c’est une classe abstraite (une interface), on l’instancie
avec une sous-classe non-abstraite.
Par exemple un List peut être instancié avec un ArrayList ou un
LinkedList. On choisit en fonction des performances voulues : un
ArrayList est très rapide en accès direct, mais très lent en
insertion. C’est l’inverse pour un LinkedList.
Rappels sur le container List<type>
Quelques méthodes utiles de la classe abstraite List, héritées par
ArrayList :

liste.size() : retourne le nombre d’éléments présents,

liste.clear() : supprime tous les éléments,
liste.add(elem) : ajoute cet élément à la liste,
liste.remove(elem ou indice) : retire cet élément
liste.get(indice) : retourne l’élément présent à cet indice,
liste.contains(elem) : true si elle contient cet élément,
liste.indexOf(elem) : indice de l’élément, s’il y est.
Données initiales dans les ressources
On crée deux tableaux dans le fichier res/values/arrays.xml :
<resources>
<string-array name="libelles">
<item>Prod1</item>
<item>Prod2</item>
...
</string-array>
<integer-array name="prix">
<item>58</item>
<item>201</item>
...
</integer-array>
</resources>

Intérêt : traduire les libelles des produits dans d’autres langues

en créant des variantes, ex: res/values-en/arrays.xml
Données dans les ressources, suite
Ensuite, on récupère ces ressources tableaux pour remplir le
ArrayList :
// accès aux ressources
Resources res = getResources();
final String[] libelles =
res.getStringArray(R.array.libelles);
final int[] prix = res.getIntArray(R.array.prix);

// recopie dans le ArrayList

liste = new ArrayList<>();
for (int i=0; i<libelles.length; ++i) {
liste.add(new Product(libelles[i], prix[i]));
}
Ça semble plus complexe, mais c’est préférable à la solution du
tableau pré-initialisé pour la séparation entre programme et données.
Remarques
Cette semaine, les données sont représentées dans un ArrayList
volatile : quand on ferme l’activité, les données sont perdues. Pour
faire un peu mieux que cela, il faut définir une classe Application
et mettre ce tableau ainsi que son initialisation dedans. Ainsi, le
tableau devient disponible dans toutes les activités de l’application.
Cependant, les données ne sont encore pas permanentes. Elles sont
perdues quand on quitte l’application.
nous verrons comment utiliser une base de données Realm locale
ou distante, au lieu de ce tableau dynamique, ce qui résout le
problème de manière élégante et rend les données persistantes
d’une exécution à l’autre.
Android - Semaine 4
Affichage de la liste

Affichage de la liste

13 / 72 Pierre Nerzic
Android - Semaine 4
Affichage de la liste

Activité spécialisée ou standard

Deux possibilités :
employer la classe ListActivity,
employer la classe Activity de base.
Ces deux possibilités sont très similaires : leur layout contient un
ListView, il y a un layout pour les items de la liste et un
adaptateur pour accéder aux données.
La ListActivity prépare un peu plus de choses pour gérer les
sélections d’items. Par exemple, si on rajoute un TextView
particulier, on peut avoir un message « La liste est vide ».
Tandis qu’avec une simple Activity, c’est à nous de tout faire,
voir page 46 pour la gestion des clics.

14 / 72 Pierre Nerzic
Android - Semaine 4
Affichage de la liste

Mise en œuvre

Dans tous les cas, deux layouts sont à définir :

1. Un layout pour l’activité ; il doit contenir un ListView
identifié par @android:id/list,
2. Un layout d’item ; il contient par exemple un TextView
identifié par @android:id/text1, ce layout est affiché pour
chaque item des données.
Consulter la documentation de ListActivity.

15 / 72 Pierre Nerzic
Android - Semaine 4
Affichage de la liste

Layout de l’activité pour afficher une liste

Voici le layout main.xml. J’ai rajouté le TextView qui affiche

« Liste vide ». Notez les identifiants spéciaux list et empty.
<LinearLayout xmlns:android="..."
android:orientation="vertical"
android:layout_width="match_parent"
android:layout_height="match_parent">
<ListView android:id="@android:id/list"
android:layout_width="match_parent"
android:layout_height="match_parent"/>
<TextView android:id="@android:id/empty"
android:text="La liste est vide"
... />
</LinearLayout>

On peut rajouter d’autres vues : boutons. . .

16 / 72 Pierre Nerzic
Android - Semaine 4
Affichage de la liste

Mise en place du layout d’activité

Classiquement :

@Override
protected void onCreate(Bundle savedInstanceState)
{
// appeler la méthode surchargée dans la superclasse
super.onCreate(savedInstanceState);

// mettre en place le layout contenant le ListView

setContentView(R.layout.main);

// initialisation de la liste
mListe = new ArrayList<>();
...

17 / 72 Pierre Nerzic
Android - Semaine 4
Adaptateurs

Adaptateurs

18 / 72 Pierre Nerzic
Android - Semaine 4
Adaptateurs

Relations entre la vue et les données

Un ListView affiche les items à l’aide d’un adaptateur (adapter).

19 / 72 Pierre Nerzic
Android - Semaine 4
Adaptateurs

Rôle d’un adaptateur

L’adaptateur répond à la question que pose le ListView : « que

dois-je afficher à tel endroit dans la liste ? ». Il va chercher les
données et instancie le layout d’item avec les valeurs.
L’adaptateur est une classe qui :
accède aux données à l’aide de méthodes telles que
getItem(int position), getCount(), isEmpty() quelque
soit le type de stockage des éléments : tableau, BDD. . .
crée les vues d’affichage des items : getView(...) à l’aide du
layout des items. Cela consiste à instancier le layout — on dit
expanser le layout, inflate en anglais.

20 / 72 Pierre Nerzic
Android - Semaine 4
Adaptateurs

Adaptateurs prédéfinis

Android propose quelques classes d’adaptateurs prédéfinis, dont :

ArrayAdapter pour un ArrayList simple,
SimpleCursorAdapter pour accéder à une base de données
SQLite (on ne verra pas).
En général, dans une application innovante, il faut définir son propre
adaptateur, voir page 30, mais commençons par un ArrayAdapter
standard.

21 / 72 Pierre Nerzic
Android - Semaine 4
Adaptateurs

ArrayAdapter<Type> pour les listes

Il permet d’afficher les données d’un ArrayList, mais il est limité à
une seule chaîne par item, par exemple le nom d’un produits,
fournie par sa méthode toString(). Son constructeur :
ArrayAdapter(Context context, int item_layout_id, int
textview_id, List<T> données)

context c’est l’activité qui crée cet adaptateur, mettre this

item_layout_id identifiant du layout des items, p. ex.
android.R.layout.simple_list_item_1 ou
R.layout.item
textview_id identifiant du TextView dans ce layout, p. ex.
android.R.id.text1 ou R.id.item_nom
données c’est la liste contenant les données (List est une
surclasse de ArrayList)
22 / 72 Pierre Nerzic
Android - Semaine 4
Adaptateurs

Exemple d’emploi
Suite de la méthode onCreate de l’activité, on fournit la
ArrayList<Product> mListe au constructeur d’adaptateur :

// créer un adaptateur standard pour mListe

ArrayAdapter<Product> adapter = new ArrayAdapter<>(this,
R.layout.item,
R.id.item_intitule,
mListe);
// associer la liste affichée et l'adaptateur
ListView lv = findViewById(android.R.id.list);
lv.setAdapter(adapter);

La classe product doit avoir une méthode toString(), cf page

6.Cet adaptateur n’affiche que le nom du produit, rien d’autre.

23 / 72 Pierre Nerzic
Android - Semaine 4
Adaptateurs

Affichage avec une ListActivity

Si l’activité est une ListActivity, la fin est peu plus simple :

@Override
protected void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);

mListe = new ArrayList<>();

...

ArrayAdapter<Product> adapter = new ArrayAdapter...

// association liste - adaptateur

setListAdapter(adapter);
}

24 / 72 Pierre Nerzic
Android - Semaine 4
Adaptateurs

Layout pour un item

Vous devez définir le layout item.xml pour afficher un item :

<TextView xmlns:android="..."
android:id="@+id/item_nom"
android:textStyle="bold"
android:layout_width="match_parent"
android:layout_height="wrap_content"/>

Ce layout est réduit à un TextView dont l’identifiant Java est

R.id.item_nom. Retrouvez les dans la création de l’adaptateur :

new ArrayAdapter<>(this,
R.layout.item, R.id.item_nom, mListe);

25 / 72 Pierre Nerzic
Android - Semaine 4
Adaptateurs

Autre layouts

Il est possible de créer des dispositions plus complexes pour les

items mais alors il faudra programmer un adaptateur spécifique.

<RelativeLayout xmlns:android="..." ...>

<ImageView android:id="@+id/item_image" .../>
<TextView android:id="@+id/item_nom" .../>
<TextView android:id="@+id/item_distance" .../>
</RelativeLayout>

Voir les adaptateurs personnalisés, page 30.

26 / 72 Pierre Nerzic
Android - Semaine 4
Adaptateurs

Layouts prédéfinis

Android définit deux layouts pour des éléments de listes simples :

android.R.layout.simple_list_item_1
C’est un layout qui affiche un seul TextView. Son identifiant
est android.R.id.text1,
android.R.layout.simple_list_item_2
C’est un layout qui affiche deux TextView : un titre en grand
et un sous-titre. Ses identifiants sont android.R.id.text1 et
android.R.id.text2.
Il suffit de les fournir à l’adaptateur. Il n’y a pas besoin de créer des
fichiers XML, ni pour l’écran, ni pour les items.

27 / 72 Pierre Nerzic
Android - Semaine 4
Adaptateurs

Exemple avec les layouts prédéfinis

Avec les layouts d’items prédéfinis Android, cela donne :

// créer un adaptateur standard pour mListe

ArrayAdapter<Product> adapter =
new ArrayAdapter<>(this,
android.R.layout.simple_list_item_1,
android.R.id.text1,
mListe);

// associer la liste affichée et l'adaptateur

setListAdapter(adapter);

Le style d’affichage est minimaliste, seulement la liste des noms. On

ne peut pas afficher deux informations avec un ArrayAdapter.

28 / 72 Pierre Nerzic