Vous êtes sur la page 1sur 16

A retenir

Choix de la Version
Chaque version d’Android, dénotée par son API level, ex: 25, apporte des améliorations et
supprime des dispositifs obsolètes.
Toute application exige un certain niveau d’API :
Minimum SDK : il faut au moins cette API car on utilise certaines classes et méthodes
absentes des précédentes APIs,
Il y a aussi deux notions à connaître :
Target SDK : l’application sera testée et marchera correctement jusqu’à ce niveau d’API,
Compile With : c’est le niveau maximal de fonctionnalités qu’on se limite à employer. Si on
fait appel à quelque chose de plus récent que ce niveau, le logiciel ne se compilera pas.

manifests : description et liste des classes de l’application


java : les sources, rangés par paquetage,
res : ressources = fichiers XML et images de l’interface, il y a des sous-dossiers :
• layout : interfaces (disposition des vues sur les écrans)
• menu : menus contextuels ou d’application
• mipmap et drawable : images, icônes de l’interface
• values : valeurs de configuration, textes. . .
Gradle scripts : c’est l’outil de compilation du projet.
Exécution de l’Application
L’application est prévue pour tourner sur un appareil (smartphone
ou tablette) réel ou simulé (virtuel).
Le SDK Android permet de :
Installer l’application sur une vraie tablette connectée par USB
Simuler l’application sur une tablette virtuelle AVD
Fenêtre Android
Android Studio affiche plusieurs fenêtres utiles indiquées dans
l’onglet tout en bas :
Logcat Affiche tous les messages émis par la tablette courante
Messages Messages du compilateur et du studio
Terminal Shell unix permettant de lancer des commandes dans le dossier du projet.
Filtrage des messages
Il est commode de définir des filtres pour ne pas voir la totalité des messages de toutes les
applications de la tablette :sur le niveau de gravité : verbose, debug, info, warn,error et assert,
sur l’étiquette TAG associée à chaque message, sur le package de l’application qui émet le
message.
Fonctions Log.*:
Log.i(String tag, String message) affiche une info,
Log.w(String tag, String message)affiche une alerte,
Log.e(String tag, String message)affiche une erreur.
Paquet
Un paquet Android est un fichier .apk.
C’est une archive signée (authentifiée) contenant les binaires, ressources compressées et
autres fichiers de données.
Création d’un écran
Chaque écran est géré par une instance d’une sous-classe perso de Activity. Sa méthode
onCreate définit, entre autres, ce qui doit être affiché sur l’écran :
Public class MainActivity extends Activity {
@Override
Protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
}
}
L’interface est mise en place par setContentView(identifiant de ressource).
Ressources de type chaînes
Dans res/values/strings.xml, on place les chaînes de l’application, au lieu de les mettre en
constantes dans le source
Référencement des ressources texte
Voici comment affecter une ressource chaîne à une vue en Java :
TextView tv =new TextView(ctx);
tv.setText(R.string.bonjour);
@string/nom est une référence à une ressource, la chaîne de res/values/strings.xml ayant ce
nom.
Identifiants et vues
Lorsque l’application veut manipuler l’une de ses vues, elle doit faire utiliser R.id.symbole, ex
TextView tv = findViewById(R.id.message);
Il y a les deux notations :
@id/nom pour référencer un identifiant déjà défini (ailleurs)
@+id/nom pour définir (créer) cet identifiant
Images : R.drawable.nom
La notation @drawable/nom référence l’image portant ce nom dans l’un des dossiers.
Structure d’une interface Android
Un écran Android de type formulaire est généralement composé de plusieurs vues (Widgets).
Entre autres :
TextView, ImageView : titre, image
EditText : texte à saisir
Button, CheckBox : bouton à cliquer, case à cocher
Ces vues sont alignées à l’aide de groupes de sous-classes de ViewGroup, éventuellement
imbriqués :
•LinearLayout : positionne ses vues en ligne ou colonne
•RelativeLayout : positionne ses vues l’une par rapport à l’autre
•TableLayout : positionne ses vues sous forme d’un tableau
•ScrollView, RecycleView un récipient conçu pour aider à la mise en œuvre des conteneurs
de défilement.
• Autres (ListView, GridView, WebView, MapView, ...)

Un bon choix pour un Viewdans un ScrollViewest un LinearLayoutqui est disposé dans


une orientation verticale.
Toutes les vues doivent spécifier ces deux attributs :
android:layout_width largeur de la vue
android:layout_height hauteur de la vue
Ils peuvent valoir :
"wrap_content" : la vue est la plus petite possible
"match_parent" : la vue est la plus grande possible "valeur
dp" : une taille fixe, ex : "100dp" mais c’est peu recommandé, sauf 0dp pour un cas
particulier
layout_weight.
Un layout_weight égal à 0 rend la vue la plus petite possible
Un layout_weight non nul donne une taille correspondant au rapport entre ce poids et la
somme des poids des autres vues
Les ressources de dimension sont situées dans le dimens.xml fichier (à l'intérieur de res>
values dans le volet Projet> Android ). Le dimens.xml fichier peut en fait être un dossier
contenant plusieurs dimens.xml fichiers, un pour chaque résolution d'écran de
périphérique. Vous pouvez éditer chaque dimens.xml fichier directement:
<resources>
<!-- Default screen margins, per the Android Design guidelines. -->
<dimen name="activity_horizontal_margin">16dp</dimen>
<dimen name="activity_vertical_margin">16dp</dimen>
<dimen name="my_view_width">300dp</dimen>
<dimen name="count_text_size">200sp</dimen>
<dimen name="counter_height">300dp</dimen>
</resources>
Les styles sont définis dans le styles.xml fichier (à l'intérieur des valeurs res> dans
le volet Projet> Android ). Vous pouvez modifier ce fichier directement. Les styles sont
traités dans un chapitre ultérieur, avec les spécifications de conception de matériaux.

Une application est composée d’une ou plusieurs activités. Chacune gère un écran
d’interaction avec l’utilisateur et est définie par une classe Java.
Une application complexe peut aussi contenir :
 des services : ce sont des processus qui tournent en arrière-plan, des fournisseurs de
contenu : ils représentent une sorte de base de données
 des récepteurs d’annonces : pour gérer des événements globaux envoyés par le
système à toutes les applications.
Le fichier AndroidManifest.xml déclare les éléments d’une application, avec un ’.’ devant
le nom de classe des activités :
<?xml version="1.0" encoding="utf-8"?>
<manifest ... >
<application android:icon="@drawable/app_icon.png" ...>
<activity android:name=".MainActivity"
... />
<activity android:name=".EditActivity" ... />…
</application></manifest>
Démarrage d’une activité et Intents
Les activités sont démarrées à l’aide d’Intents.
Pour faire communiquer les deux activés il faut passer par un Intent.
Ce dernier représente l’intention de faire quelque chose, et permet à l’activité principale de
lancer une autre activité
Les intents explicites
Créer un intent explicite est très simple puisqu’il suffit de donner un Context qui appartienne
au package où se trouve la classe de destination :
Intent intent = new Intent(Context context, Class<?> cls);
Il existe ensuite deux façons de lancer l’intent, selon qu’on veuille que le composant de
destination nous renvoie une réponse ou pas.
Les intents implicites
Ici, on fera en sorte d’envoyer une requête à un destinataire, sans savoir qui il est, et d’ailleurs
on s’en fiche tant que le travail qu’on lui demande de faire est effectué. Ainsi, les applications
destinataires sont soit fournies par Android, soit par d’autres applications téléchargées sur le
Play Store par exemple.
Un Intent est constitué de:
– Action à réaliser
– Donnée sur laquelle réaliser l'action sous forme d'URI (setData()) ou d'un type MIME
(setType())
– Paramètre optionnels (EXTRA)
● Création d'un Intent
– Intent(Context, Class) pour l'appels explicite
– Intent(String action, URI) pour l'appel implicite
– addCategory(String category) ajout de catégories – putExtra(String key,value)
– setFlags(flags) permission sur les données, relation activité/BackStack
La première lance la seconde par :
Intent intent = new Intent(this, Activ2.class); startActivity(intent);
On peut demander la terminaison de this après lancement de Activ2 ainsi :
Intent intent = new Intent(this, Activ2.class);
startActivity(intent);
finish();
Au début, le système Android lance l’activité qui est marquée action=MAIN et
catégorie=LAUNCHER dans AndroidManifest.xml.
Lancement avec attente de résultat
Le lancement d’une activité avec attente de résultat est plus complexe. Il faut définir un code
d’appel RequestCode fourni au lancement. private static final int APPEL_ACTIV2 = 1;
Intent intent = new Intent(this, Activ2.class);
startActivityForResult(intent, APPEL_ACTIV2);

Utilisez la setResult() méthode avec un code de réponse et Intent avec les données de réponse:
setResult(RESULT_OK,replyIntent);
Les codes de réponse sont définis par la Activityclasse et peuvent être
 RESULT_OK: La demande a réussi.
 RESULT_CANCELED: L'utilisateur a annulé l'opération.
 RESULT_FIRST_USER: Pour définir vos propres codes de résultat.

Maintenant que le lancé Activity a renvoyé des données à l'origine Activity avec
un Intent, celui-ci Activity doit d' abord gérer ces données. Pour gérer les données
renvoyées dans l'origine Activity, implémentez la onActivityResult()méthode de
rappel. Voici un exemple simple.
public void onActivityResult(int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);
if (requestCode == TEXT_REQUEST) {
if (resultCode == RESULT_OK) {
String reply =
data.getStringExtra(SecondActivity.EXTRA_RETURN_MESSAGE);
// process data
}
}
}
Les trois arguments pour onActivityResult()contenir toutes les informations dont vous
avez besoin pour gérer les données de retour.
Code de demande: le code de demande que vous avez défini lorsque vous avez lancé
le Activityavec startActivityForResult(). Si vous lancez une opération
différente Activitypour accomplir différentes opérations, utilisez ce code pour identifier
les données spécifiques que vous récupérez.
Code de résultat: le code de résultat défini dans le fichier lancé Activity, généralement l'un
des RESULT_OK ou RESULT_CANCELED.
Les données d' intention: le Intentcontenant les données renvoyées par le
lancement Activity.

Le système Android prend en charge deux formes différentes de stratégies de navigation


pour votre application.
 Navigation arrière (temporelle) back, fournie par le bouton Retour de l'appareil et la
pile arrière.
 Navigation ascendante (ancestrale) up, fournie par vos soins en option dans la barre
d'application.
Up
<activity android:name=".SecondActivity"
android:label = "Second Activity"
android:parentActivityName=".MainActivity">
<meta-data
android:name="android.support.PARENT_ACTIVITY"
android:value="com.example.android.twoactivities.MainActivity" />
</activity>

Transport d’informations dans un Intent


Les Intent servent aussi à transporter des informations d’une activité à l’autre : les extras.
Intent intent = new Intent(this, DeleteInfoActivity.class); intent.putExtra("idInfo", idInfo);
intent.putExtra("hiddencopy", hiddencopy); startActivity(intent);

Ces instructions récupèrent les données d’un Intent:


getIntent() retourne l’Intent qui a démarré cette activité. getTypeExtra(nom, valeur par défaut)
retourne la valeur de ce nom si elle en fait partie, la valeur par défaut sinon.
Ou bien
Ou vous pouvez obtenir tous les extras à Bundlepartir de Intentet extraire les valeurs avec les
différentes Bundleméthodes:
Bundle extras = intent.getExtras();
String message = extras.getString(MainActivity. EXTRA_MESSAGE) ;
Contexte d’application
Il y a un objet global vivant pendant tout le fonctionnement d’une application : le contexte
d’application. Voici comment le récupérer :
Application context = this.getApplicationContext();
Pour commencer, dériver une sous-classe de Application : public class MonApplication
extends Application
{
// variable globale de l'application
// initialisation du contexte
}
la déclarer dans AndroidManifest.xml, dans l’attribut android:name de l’élément
<application>, mettre un point devant :
<manifest xmlns:android="..." ...> <application android:name=".MonApplication"…
Enfin, l’utiliser dans n’importe laquelle des activités :
// récupérer le contexte d'application
MonApplication context =
(MonApplication) this.getApplicationContext();
// utiliser la variable globale
... context.getVarGlob() ...
Une activité possède quatre états que sont :
 « Active » : l'activité est lancée par l'utilisateur, elle s'exécute au premier plan ;
 « En Pause » : l'activité est lancée par l'utilisateur, elle s'exécute et est visible, mais
elle n'est plus au premier plan. Une notification ou une autre activité lui a volé le focus
et une partie du premier plan ;
 « Stoppée » : l'activité a été lancée par l'utilisateur, mais n'est plus au premier plan et
est invisible. L'activité ne peut interagir avec l'utilisateur qu'avec une notification ;
 « Morte » : l'activité n'est pas lancée.
La méthode onCreate est appelée :
 au premier lancement de l'activité ;
 si l'activité est ressuscitée, le bundle passé en paramètre sera celui sauvegardé par
onSaveInstanceState() ;
 si l'état du terminal change et que l'activité est associée à cet état (passage du mode
portrait au mode paysage).
Elle configure les IHM et tous les traitements d'initialisation qui ne sont effectués qu'une seule
fois au lancement de l'activité.
La méthode onDestroy est appelée lors de la mort de l'activité (soit naturelle, soit par le
système). Parfois, l'urgence du système détruira l'activité sans même appeler onDestroy. Cette
méthode doit libérer les ressources allouées dans la méthode onCreate. La seule méthode qui
est appelée avec certitude avant la destruction de l'activité est onPause().
Les méthodes onStart, onRestart et onStop n'ont pas grand intérêt.
Les méthodes onPause et onResume sont celles dans lesquelles l'activité doit sauvegarder ses
états et les restituer.
La méthode onResume est appelée immédiatement avant que l'activité ne passe au premier
plan. De ce fait, c'est le bon endroit pour reconstruire les données affichées par l'IHM et
mettre celle-ci à jour, quitte à lancer un thread de reconstruction des données.
Enregistrement de valeurs d’une exécution à l’autre
public void onSaveInstanceState(Bundle etat) {
// enregistrer l'état courant
etat.putInt(ETAT_SCORE, mScoreJoueur); super.onSaveInstanceState(etat);
}

Restaurer l’état au lancement


@Override
protected void onRestoreInstanceState(Bundle etat) { super.onRestoreInstanceState(etat);
// restaurer l'état précédent
mScoreJoueur = etat.getInt(ETAT_SCORE); }

 Enregistrez l' Activity état de l'instance dans la onSaveInstanceState()méthode.


 Les données d'état de l'instance sont stockées sous forme de simples paires clé / valeur
dans un fichier Bundle. Utilisez les Bundleméthodes pour insérer des données et les
extraire du Bundle.
 Restaurez l'état de l'instance dans onCreate(), qui est la méthode préférée,
ou onRestoreInstanceState().

Définition d’un écouteur


Il y a une autre manière de définir une réponse à un clic : un écouteur (listener).
C’est une instance de classe qui possède la méthode public void onClick(View v) ainsi que
spécifié par l’interface View.OnClickListener.
Cela peut être :
une classe privée anonyme,
une classe privée ou public dans l’activité,
l’activité elle-même.
button.setOnClickListener(new View.OnClickListener() {
// ... The onClick method goes here.
}

Pour implémenter un Activity dans votre application, procédez comme suit:


--Créez une Activityclasse Java.
--Implémentez une interface utilisateur de base pour le Activity dans un fichier de mise en
page XML.
--Déclarez le nouveau Activitydans le AndroidManifest.xmlfichier.
L' <activity>élément peut également inclure des déclarations pour
les Intentfiltres. Les Intentfiltres spécifient le type de Intentvotre Activityacceptation.
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
Afficher un Toastmessage:
Toast.makeText(getApplicationContext(),message,
Toast.LENGTH_SHORT).show();

Commandes d'entrée pour faire des choix


Android propose des commandes de saisie prêtes à l'emploi permettant à l'utilisateur de
sélectionner un ou plusieurs choix:
 Checkbox: Sélectionnez un ou plusieurs choix parmi un ensemble de choix en
appuyant ou en cliquant sur les cases à cocher.
 RadioGroupde boutons radio: sélectionnez un choix parmi un ensemble de choix en
cliquant sur un bouton "radio" circulaire. Les boutons radio sont utiles si vous ne
proposez que deux ou trois choix.
 ToggleButtonet Switch: activer ou désactiver une option.
 Spinner: Sélectionnez un choix parmi un ensemble de choix dans un menu
déroulant. A Spinnerest utile pour trois choix ou plus et prend peu de place dans
votre mise en page.
Vous pouvez également définir explicitement le focus ou découvrir lequel Viewa le focus à
l'aide des méthodes suivantes:
 Appelez onFocusChangedpour déterminer d'où vient la concentration.
 Pour savoir qui a Viewactuellement le focus, appelez Activity.getCurrentFocus()ou
utilisez ViewGroup.getFocusedChild()pour renvoyer l'enfant focalisé de a View(le
cas échéant).
 Pour rechercher le Viewdans la hiérarchie qui a actuellement le focus,
utilisez findFocus().
 Utilisez requestFocuspour mettre l'accent sur un élément spécifique View.
 Pour modifier si un Viewpeut prendre le focus, appelez setFocusable.
 Pour définir un écouteur qui est notifié lorsque le Viewfocus gagne ou perd le
focus, utilisez setOnFocusChangeListener.
Checbox
La isChecked()méthode retourne trues'il y a une coche dans la case. Par exemple,
l'instruction suivante affecte trueou falseà checked, selon que la case est cochée ou non:
boolean checked = ((CheckBox) view).isChecked();

exemple :
public void onSubmit(View view) {
StringBuffer toppings = new
StringBuffer().append(getString(R.string.toppings_label));
if (((CheckBox) findViewById(R.id.checkbox1_chocolate)).isChecked()) {
toppings.append(getString(R.string.chocolate_syrup_text));
}
if (((CheckBox) findViewById(R.id.checkbox2_sprinkles)).isChecked()) {
toppings.append(getString(R.string.sprinkles_text));
}
if (((CheckBox) findViewById(R.id.checkbox3_nuts)).isChecked()) {
toppings.append(getString(R.string.crushed_nuts_text));
}
// Code to display the result...
}

RadioButton

un gestionnaire de clic onRadioButtonClicked(), pour tous les RadioButtonéléments


du RadioGroup. Il utilise un switch casebloc pour vérifier la ressource idde
l' RadioButtonélément afin de déterminer lequel a été vérifié:
public void onRadioButtonClicked(View view) {
// Check to see if a button has been clicked.
boolean checked = ((RadioButton) view).isChecked();
// Check which radio button was clicked.
switch(view.getId()) {
case R.id.sameday:
if (checked)
// Code for same day service ...
break;
case R.id.nextday:
if (checked)
// Code for next day delivery ...
break;
case R.id.pickup:
if (checked)
// Code for pick up ...
break;
}
}
Spinner
Pour créer un spinner, utilisez la Spinnerclasse, qui crée un Viewqui affiche les valeurs de
spinner individuelles en tant Viewqu'éléments enfants et permet à l'utilisateur d'en choisir
un. Suivez ces étapes:
1. Créez un Spinnerélément dans votre mise en page XML et spécifiez ses valeurs à
l'aide d'un tableau et d'un ArrayAdapter.
2. Créez le Spinner et son adaptateur à l'aide de la SpinnerAdapterclasse.
3. Pour définir le rappel de sélection pour le Spinner, mettez à jour le Activityqui
utilise le Spinnerpour implémenter
l' AdapterView.OnItemSelectedListenerinterface.

@Override
protected void onCreate(Bundle savedInstanceState) {
// ... Rest of onCreate code ...
// Create the spinner.
Spinner spinner = findViewById(R.id.label_spinner);
if (spinner != null) {
spinner.setOnItemSelectedListener(this);
}
// Create ArrayAdapter using the string array and default spinner layout.

ArrayAdapter<CharSequence> adapter = ArrayAdapter.createFromResource(this,


R.array.labels_array, android.R.layout.simple_spinner_item);
// Specify the layout to use when the list of choices appears.
adapter.setDropDownViewResource
(android.R.layout.simple_spinner_dropdown_item);
// Apply the adapter to the spinner.
if (spinner != null) {
spinner.setAdapter(adapter);
}
}
public void onItemSelected(AdapterView<?> adapterView, View view, int
i, long l) {
String spinner_item = adapterView.getItemAtPosition(i).toString();
// Do something with spinner_item string.
}
toggleButton
public void onToggleClick(View view) {
ToggleButton toggle = findViewById(R.id.my_toggle);
toggle.setOnCheckedChangeListener(new
CompoundButton.OnCheckedChangeListener() {
public void onCheckedChanged(CompoundButton buttonView,
boolean isChecked) {
StringBuffer onOff = new StringBuffer().append("On or off? ");
if (isChecked) { // The toggle is enabled
onOff.append("ON ");
} else { // The toggle is disabled
onOff.append("OFF ");
}
Toast.makeText(getApplicationContext(), onOff.toString(),
Toast.LENGTH_SHORT).show();
}
});
}
Switch
public void onSwitchClick(View view) {
Switch aSwitch = findViewById(R.id.my_switch);
aSwitch.setOnCheckedChangeListener(new
CompoundButton.OnCheckedChangeListener() {
public void onCheckedChanged(CompoundButton buttonView,
boolean isChecked) {
StringBuffer onOff = new StringBuffer().append("On or off? ");
if (isChecked) { // The switch is enabled
onOff.append("ON ");
} else { // The switch is disabled
onOff.append("OFF ");
}
Toast.makeText(getApplicationContext(), onOff.toString(),
Toast.LENGTH_SHORT).show();
}
});
}
Les attributs suivants sont généralement utilisés pour personnaliser un EditText:
 android:inputType="textCapCharacters": Définissez l'entrée de texte sur toutes les
lettres majuscules.
 android:inputType="textCapSentences": Commencez chaque phrase par une
majuscule.
 android:inputType="textMultiLine": Définissez le champ de texte pour activer
plusieurs lignes. Cette valeur est utile pour la combinaison avec d'autres
attributs. Pour combiner des valeurs, concaténez-les à l'aide du caractère pipe ( |).
 android:inputType="textPassword": Transforme chaque caractère saisi par
l'utilisateur en un point pour masquer un mot de passe saisi.
 android:inputType="number": Restreindre la saisie de texte aux nombres.
 android:textColorHighlight="#7cff88": Définir la couleur d'arrière-plan du texte
sélectionné (surligné).
 android:hint="@string/my_hint": Définissez le texte pour qu'il apparaisse dans le
champ qui fournit un conseil à l'utilisateur, tel que "Saisir un message".
Menu d’option

1. Bouton de navigation ou bouton Haut: utilisez un bouton de navigation dans cet


espace pour ouvrir un panneau de navigation, ou utilisez un bouton Haut pour
naviguer dans la hiérarchie d'écran de votre application jusqu'à l'activité parent. Les
deux sont décrits dans le chapitre suivant.
2. Titre: le titre dans la barre d'application est le titre de l'application ou le nom défini
dans AndroidManifest.xml par l' android:labelattribut de l'activité.
3. Icônes d'action pour le menu d'options: chaque icône d'action apparaît dans la barre
d'application et représente l'un des éléments les plus fréquemment utilisés du menu
d'options. Les éléments du menu d'options les moins fréquemment utilisés
apparaissent dans le menu d'options de débordement.
4. Menu d'options de débordement: l' icône de débordement ouvre une fenêtre
contextuelle avec des éléments du menu d'options qui ne sont pas affichés sous
forme d'icônes dans la barre d'applications.
Etapes pour implémenter options menu
1. Ressource de menu XML . Créez un fichier de ressources de menu XML pour les
éléments de menu et attribuez des attributs d'apparence et de position comme décrit
dans la section suivante.
2. Gonfler le menu . Remplacez la onCreateOptionsMenu()méthode de
votre Activitypour gonfler le menu.
3. Gestion des clics sur les éléments de menu . Les éléments de menu sont
des Viewéléments, vous pouvez donc utiliser l' android:onClickattribut pour chaque
élément de menu. Cependant, la onOptionsItemSelected()méthode peut gérer tous
les clics sur les éléments de menu en un seul endroit et déterminer sur quel élément
de menu l'utilisateur a cliqué, ce qui facilite la compréhension de votre code.
4. Effectuer des actions . Créez une méthode pour exécuter une action pour chaque
élément du menu d'options.

Etapes pour implémenter menu Contextuel


1. Créez un fichier de ressources de menu XML pour les éléments de menu. Attribuez
les attributs d'apparence et de position comme décrit dans la section précédente du
menu d'options.
2. Enregistrez a Viewdans le menu contextuel à l'aide de
la méthode registerForContextMenu() de la Activityclasse.
3. Implémentez la onCreateContextMenu()méthode dans votre Activitypour gonfler le
menu.
4. Implémentez la onContextItemSelected()méthode dans votre Activitypour gérer les
clics sur les éléments de menu.
5. Créez une méthode pour exécuter une action pour chaque élément du menu
contextuel.

Etapes pour implémenter Contextuel Action Bar


1. Créez un fichier de ressources de menu XML pour les éléments de menu et
attribuez une icône à chacun d'eux (comme décrit dans une section précédente).
2. Définissez l'écouteur à clic long sur setOnLongClickListener()le Viewqui doit
déclencher la barre d'actions contextuelles. Appelez startActionMode()dans
la setOnLongClickListener()méthode lorsque l'utilisateur effectue un appui long sur
le View.
3. Implémentez l' ActionMode.Callbackinterface pour gérer le ActionModecycle de
vie. Incluez dans cette interface l'action de réponse à un clic d'élément de menu
dans la onActionItemClicked()méthode de rappel.
4. Créez une méthode pour exécuter une action pour chaque élément du menu
contextuel.
Etapes pour implémenter menu PopUp
1. Créez un fichier de ressources de menu XML pour les éléments de menu contextuel
et attribuez des attributs d'apparence et de position (comme décrit dans une section
précédente).
2. Ajoutez une ImageButtonicône de menu contextuel dans le fichier de mise en page
d'activité XML.
3. Attribuer onClickListener()au ImageButton.
4. Remplacez la onClick()méthode pour gonfler le menu contextuel et enregistrez-le
avec PopupMenu.OnMenuItemClickListener.
5. Implémentez la onMenuItemClick()méthode.
6. Créez une méthode pour exécuter une action pour chaque élément de menu
contextuel.

AlertDialog___DatePicker---- TimePicker
AlertDialog can show:
1. Title (optional)
2. Content area
3. Action buttons
alertDialog.setPositiveButton()
alertDialog.setNeutralButton()
alertDialog.setNegativeButton()
Sous Android, créer une boîte de dialogue passe par:
1. Instancier la classe AlertDialog.Builder pour construire l’interface avec les éléments
nécessaires (boutons, titre, icones,…)
2. Modifier les propriétés de l’objet de type AlertDialog.Builder (boutons, titre, icones,…)
3. Instancier un objet de type AlertDialog selon le AlertDialog.Builder adéquat
4. Afficher la boîte de dialogue
Up back
1. Bouton Haut pour la navigation ancestrale des frères et sœurs de premier niveau
vers le parent.
2. Bouton Haut pour la navigation ancestrale des frères et sœurs de deuxième niveau
vers l'écran enfant de premier niveau faisant office d'écran parent.
Navigation Drawer

1. Populate navigation drawer menu with item titles and icons


2. Set up navigation drawer and item listeners in the Activity code
3. Handle the navigation menu item selections

Descendant navigation
1. Icon in app bar
2. Header
3. Menu items
TabLayout
1. Define the tab layout using TabLayout
2. Implement a Fragment and its layout for each tab
3. Implement a PagerAdapter from FragmentPagerAdapter or
FragmentStatePagerAdapter
4. Create an instance of the tab layout
5. Use PagerAdapter to manage screens (each screen is a Fragment)
6. Set a listener to determine which tab is tapped
Les étapes clés de la mise en œuvre des onglets sont les suivantes TabLayout:
1. Définissez la disposition des onglets. La classe principale utilisée pour afficher les
onglets est TabLayout. Il fournit une disposition horizontale pour afficher les
onglets. Vous pouvez afficher les onglets sous la barre d'applications.
2. Implémentez un Fragmentpour chaque écran de contenu d'onglet. A Fragmentest un
comportement ou une partie d'une interface utilisateur dans un
fichier Activity. C'est comme un mini- Activitydans le principal Activity, avec son
propre cycle de vie. L'un des avantages de l'utilisation d'un Fragmentpour chaque
contenu à onglets est que vous pouvez isoler le code pour gérer le contenu à onglets
dans le Fragment. Pour en savoir plus Fragment, consultez Fragments dans le guide
API.
3. Ajoutez un adaptateur de téléavertisseur. Utilisez la PagerAdapterclasse pour
remplir des «pages» (écrans) à l'intérieur de a ViewPager, qui est un gestionnaire de
mise en page qui permet à l'utilisateur de parcourir les écrans de données à gauche
et à droite. Vous fournissez une implémentation d'un PagerAdapterpour générer les
écrans que le Viewmontre. ViewPagerest le plus souvent utilisé en conjonction
avec Fragment, qui est un moyen pratique de fournir et de gérer le cycle de vie de
chaque écran.
4. Créez une instance de la mise en page de l'onglet et définissez le texte de chaque
onglet.
5. Permet PagerAdapterde gérer les écrans ("pages"). Chaque écran est représenté par
le sien Fragment.
6. Définissez un écouteur pour déterminer quel onglet est touché.

RecycleView

1. Add RecyclerView dependency to build.gradle if needed


2. Add RecyclerView to layout
3. Create XML layout for item
4. Extend RecyclerView.Adapter
5. Extend RecyclerView.ViewHolder
6. In Activity onCreate(), create RecyclerView with adapter and layout manager

La mise en œuvre d'un RecyclerViewnécessite les étapes suivantes:


1. Ajoutez la RecyclerViewdépendance si nécessaire (selon le modèle utilisé pour
le Activity).
2. Ajoutez le RecyclerViewà la Activitymise en page.
3. Créez un fichier XML de mise en page pour un Viewélément.
4. Étendez RecyclerView.Adapteret implémentez
les méthodes onCreateViewHolder()et onBindViewHolder().
5. Étendez RecyclerView.ViewHolderpour créer une ViewHoldermise en page pour
votre élément. Vous pouvez ajouter un comportement de clic en remplaçant
la onClick()méthode.
6. Dans le Activity, à l'intérieur de la onCreate()méthode, créez un RecyclerViewet
initialisez-le avec l'adaptateur et un gestionnaire de disposition.
Création du RecyclerView
Enfin, pour tout lier, ajoutez à Activityce qui suit:
1. Déclarez un RecyclerView.
private RecyclerView mRecyclerView;
2. Dans la Activity onCreate()méthode, obtenez un handle vers le RecyclerViewdans la
disposition:
mRecyclerView = findViewById(R.id.recyclerview);
3. Créez un adaptateur et fournissez les données à afficher.
mAdapter = new WordListAdapter(this, mWordList);
4. Connectez l'adaptateur avec le RecyclerView.
mRecyclerView.setAdapter(mAdapter);
5. Donnez au RecyclerView gestionnaire de mise en page par défaut.
mRecyclerView.setLayoutManager(new LinearLayoutManager(this));