ANDROID – Semestre 2 https://openclassrooms.com/fr/courses/2023346-creez-des-applications-pour- android/2023483-lunivers-android

(1)

ANDROID Interfaces graphiques - page 1/103

ANDROID – Semestre 2

https://openclassrooms.com/fr/courses/2023346-creez-des-applications-pour- android/2023483-lunivers-android

2 - INTERFACE GRAPHIQUE AVANCEE

Sommaire

• 1 : éditeur Android : https://openclassrooms.com/fr/courses/2023346-creez-des- applications-pour-android/2024435-constitution-des-interfaces-graphiques

• 2 : les widgets : https://openclassrooms.com/fr/courses/2023346-creez-des- applications-pour-android/2024698-les-widgets-les-plus-simples

• 3 : les layout : https://openclassrooms.com/fr/courses/2023346-creez-des- applications-pour-android/2024892-organiser-son-interface-avec-des-layouts Sommaire détaillé :

1. Editeur de mise en page (Layout editor) ... 2

2. Les widgets ... 8

3 : Les événements et les listeners... 14

4 : Le layout (layout = mise en page) ... 21

4.1 : LinearLayout ... 22

4.2 : RelativeLayout ... 24

4.3 : Autres layouts ... 26

5 : Ressources - inflater ... 27

5.1 : Les styles ... 33

5.2 : Les animations... 37

6.1 : Widget+ : Les boites de dialogue ... 44

6.2 : Widget+ : Date et heure ... 47

5.3 : Menu d’options (menu d’application) ... 48

5.4 : Menu contextuel ... 53

5.5 : Autres menus ... 54

6.3 : Widget+ : Les listes – Adapter et AdapterView ... 55

6.4 : Widget+ : GridView ... 60

6.5 : Widget+ : Spinner : liste défilante ... 61

Inflat – inflater – désérialiser... 64

6.5 : Widget+ : Les adapteurs personnalisés ... 70

7 : BD – SQLite ... 83

8 : La classe Cursor et SQLite ... 94

9 : Cursor et Adapter ... 96

(2)

10 : API JSON et Android ... 102 Réponses à certaines questions du document ... 103

1. Editeur de mise en page (Layout editor) La fenêtre

• https://openclassrooms.com/fr/courses/2023346-creez-des-applications-pour- android/2024435-constitution-des-interfaces-graphiques#/id/r-2024351

• Quand on ouvre un fichier XML d’activité dans Android

(res/layout/activity_main.xml), on a une fenêtre avec 2 onglets en bas à gauche : Design et Text

• L’onglet Text donne accès au code.

• L’onglet Design donne accès à l’éditeur de mise en page.

Editeur vs XML

• L’éditeur est pratique pour une première approche rapide.

• Le XML permet de s’assurer que le code est propre.

(3)

Canvas

• Le « canvas » (toile en français), c’est la fenêtre centrale de prévisualisation.

Le tableau de bord

• C’est l’ensemble des boutons de la fenêtre sur la ligne du haut qui permet de : 1) Changer de terminal (type de téléphone, tablette, etc.)

2) Changer de ressources : de langue, de format d’affichage.

3) Quand on ouvre un fichier xml d’activité dans Android

(res/layout/activity_main.xml), on a une fenêtre avec 2 onglets en bas à gauche : Design et Text.

• L’onglet AppTheme sera abordé plus tard La palette : fenêtre de gauche

• La fenêtre de gauche permet de sélectionner les éléments graphiques qu’on va mettre dans le Canvas.

• On peut modifier la position et la dimension des éléments dans le Canvas Fenêtre de droite

• Quand on sélectionne un élément du Canvas, on fait apparaître ses caractéristiques, qui sont modifiables dans la fenêtre de droite.

Onglet Text

• On peut toujours afficher le code XML correspondant.

Détails

• Il faut noter que la présentation OCR traite d’une ancienne version d’Android Studio.

La version 2020 propose en particulier la fenêtre de droite en plus.

(4)

Rappels des principales caractéristiques des éléments d’écran en XML

• Distinction layout - widget

o Un widget est un élément de base de l’écran qui permet d’afficher du contenu et d’interagir. Un widget fournie du contenu.

o Un layout s’occupe de la mise en page : la position dans l’écran, la taille des éléments, etc.

• Éléments de l’écran (les widgets) o TextView : pour éditer un texte o EditView : pour saisir un texte o CheckBox : une case à cocher o Spinner : liste de choix o Button : bouton à cliquer o Etc.

• Position des éléments dans un écran :

o Linéaire : les éléments sont les uns à la suite des autres, horizontalement ou verticalement : <LinearLayout android :orientation=« vertical »>

o Absolue : chaque éléments est positionné avec ses coordonnées.

o Relative : les éléments sont disposées les uns par rapport aux autres.

o En bordure : les éléments sont disposées par rapport aux bordures de l’écran, comme s’ils étaient aimantés.

o En grille : l’écran est découpé par une grille et les éléments sont positionnés dans la grille.

• Taille des éléments :

o Largeur : android:layout_width : pour la largeur d’un élément.

« wrap_content » : espace minimum. « match_content » : largeur du parent.

« 10 dp » : taille fixe.

o Hauteur : android:layout_height :pour la hauteur d’un élément.

o Gravity : android:layout_gravity : positionnement par rapport à son parent.

« center_horizontal », « center_vertical » : centré par rapport au parent.

« left », « right », « top », « end » : calé à gauche, à droite, en haut, en bas.

« start » : au début, top ou left selon les cas.

(5)

Précisions sur les balises <Layout>

https://openclassrooms.com/fr/courses/2023346-creez-des-applications-pour- android/2024435-constitution-des-interfaces-graphiques#/id/r-2024390

• La racine de l’ecran XML est une balise <Layout>

• Ca peut être <RelativeLayout> ou <ConstraintLayout> ou <LinearLayout> ou d’autres.

• Ca peut être préfixée ou pas : <androidx.constraintlayout.widget.ConstraintLayout ou

<LinearLayout

• Le layout contient les balises à afficher : une balise qui ne peut pas en contenir d’autres est appelée : « widget » ou « composant ».

• Le layout contient aussi des attributs.

• Le premier xmlns :android= «…» est obligatoire.

• Les autres précisent des caractéristiques générales.

Précisions sur le padding

• padding, paddingTop, paddingBottom, paddingRight, paddingLeft

• en java : public void setPadding (int left, int top, int right, int bottom) Précisions sur les identifiants

• identifiant : @X/Y. Les identifians sont utilisés pour accéder aux ressource.Le @ signifie qu’on va parler d’un identifiant. Le X est la classe où se situe l’identifiant dans R.java. Y est le nom de l’identifiant.

• Par exemple : android:text="@string/hello_world" veut dire qu’on récupère

l’identifiant hello_world dans la classe string qui se trouve dans res/values (il faut la créer et y mettre hello_world avec une valeur.

• Identifiant de vue : @+X/Y. Sert à faire le lien entre la vue et le java. S’applique à l’attribut « id ». Traditionnellement, X vaut « id »

• Par exemple : android:id="@+id/text"

(6)

Technique Java : fichier R et instanciation des composants XML

• Quand on sauvegarde le layout, ça met à jour le fichier R (qui définit la classe R).

• La classe R (pour Resources), contient l'ensemble des identifiants de toutes les ressources du projet. Ces ressources peuvent être des fichiers layout, des chaînes de caractères, etc.

• Par exemple, le fichier R contient une class string, du fait du android:text="@string/hello_world" :

o La class string est une classe qui ne contient que des attributs de classe (static) non modifiables (final).

o Le @string/hello_world a été défini dans res/values/strings.xml :

<string name="hello_world">Super Hello</string>

(7)

Technique Java : instanciation des composants XML

• Dans le onCreate, on trouve : setContentView :

o La méthode setContent View permet de setter la vue XML à l’écran (l’objet Java en cours pour l’Activity). Le fichier XML est un arbre de balises. La méthode peut construire cet arbre.

• Après le setContentView, on fait un findViewById :

o La méthode findViewById transforme le XML de la balise identifiée par un id en un objet Java. Cette opération est appelée : « désérialisation ».

o A noter qu’il existe une méthode inflate() qui permet de faire des choses équivalentes de façon plus compliquée !

(8)

2. Les widgets

Documentation Android https://developer.android.com/

OCR

https://openclassrooms.com/fr/courses/2023346-creez-des-applications-pour- android/2024698-les-widgets-les-plus-simples

Distinction layout - widget

• Un widget est un élément de base de l’écran qui permet d’afficher du contenu et d’interagir. Un widget fournit du contenu.

• Un layout s’occupe de la mise en page : la position dans l’écran, la taille des éléments, etc.

TextView

• Exemple :

<TextView

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="@string/textView"

android:textSize="12sp"

android:textColor="#112233" />

• Notez : text, textSize, sp (plutôt que dp pour le texte), textColor.

• En Java : on peut écrire :

o textView.setText(R.string.textView);

o textView.setTextSize(8);

o textView.setTextColor(0x112233); // 0x ou #

EditText

• Exemple :

<EditText

android:layout_width="fill_parent"

android:hint="@string/editText"

android:inputType="textMultiLine"

android:lines="5" />

• Notez : hint, inputType et lines.

• hint équivaut au placeholder html (texte en grisé qui disparaît à la saisie).

o EditText editText = new EditText(this);

o editText.setHint(R.string.editText);

o editText.setInputType(InputType.TYPE_TEXT_FLAG_MULTI_LINE);

o editText.setLines(5);

(9)

Button

• XML :

o <Button

o Button button = new Button(this);

o button.Text(R.string.button);

CheckBox

• XML :

o <Button

o CheckBox checkBox = new CheckBox(this);

o checkBox.setText(R.string.checkBox);

o checkBox.setChecked(true)

o if(checkBox.isChecked() ) Button button = new Button(this);

(10)

RadioButton et RadioGroup

• On regroupe les RadioButton dans un RadioGroup.

• RadioGroup est un Layout, RadioButton est un Widget.

• Une fois regroupé, on ne peut en cocher qu’un seul.

• XML :

• Java :

o RadioGroup radioGroup = new RadioGroup(this);

o RadioButton radioButton1 = new RadioButton(this);

o

o // On ajoute les boutons au RadioGroup o radioGroup.addView(radioButton1, 0);

o radioGroup.addView(radioButton2, 1);

o radioGroup.addView(radioButton3, 2);

o

o // On sélectionne le premier bouton o radioGroup.check(0);

o

o // On récupère l'identifiant du bouton qui est coché o int id = radioGroup.getCheckedRadioButtonId();

• A noter : la méthode addView() : on y reviendra dans le petit TP suivant.

• https://o7planning.org/fr/10505/tutoriel-android-radiogroup-et-de-radiobutton

(11)

Toast

Présentation :

• Un Toast est un widget particulier qui permet d'afficher un message à n'importe quel moment sans avoir à créer de vue.

• Techniquement, il n’hérite pas de View mais directement de Object.

• Documentation :

o https://developer.android.com/reference/android/widget/Toast o https://developer.android.com/guide/topics/ui/notifiers/toasts

• Il est destiné à informer l'utilisateur sans modifier la page.

• Il contient en particulier une méthode static makeText Syntaxe :

static Toast makeText(

Context context, CharSequence texte, int duration

)

o Le contexte peut être MainActivity.this

o La durée peut-être : Toast.LENGTH_SHORT (une constante de la classe)

Usage :

• La méthode makeText permet de préparer un texte à afficher. Elle retourne un objet Toast.

• On peut alors lui appliquer la méthode show() qui gère l’affichage.

Toast.makeText(

MainActivity.this,

"coucou dans un toast", Toast.LENGTH_SHORT

).show();

o On appelle la méthode makeText() qui est static à partir de sa classe, Toast. Elle retourne un objet Toast sur lequel on applique la méthode show().

o La durée peut-être : Toast.LENGTH_SHORT (une constante de la classe)

(12)

Documentation Android

• La documentation Android ressemble à la documentation Java : o Android : https://developer.android.com/

o Java 8 : https://docs.oracle.com/javase/8/docs/api/

o Java 10 : https://docs.oracle.com/javase/10/docs/api/index.html?overview- summary.html

• Elle permet d’accéder aux classes, aux méthodes, aux attributs, aux parents, aux enfants, aux interfaces.

TP 2 : chercher la méthode addView()

• On a fait : radioGroup.addView(radioButton1, 0);

• Expliquez :

o d’où vient cette méthode o à quoi elle sert

o quelles sont les principales classes en jeu ?

o Qui est parent d’un RadioGroup ? Quels sont les enfants des RadioGroup ? o Qui est parent d’un RadioButton ? Quels sont les enfants d’un TextEdit ?

• On a fait : radioGroup.check(0);

• Expliquez :

o d’où vient cette méthode o ce qu’elle fait

o quelle autre méthode elle utilise o quel attribut elle met à jour.

• Réponse (cherchez avant de regarder !) : ici

(13)

TP 3 : IHM du projet IMC Créer un nouveau projet

• Créer un nouveau projet.

• Codez l’écran suivant avec l’éditeur de mise en page.

• Ensuite, vérifiez votre code et faites une version XML « à la main ».

• Vous pouvez aussi coder directement en XML et regarder à quoi cela correspond dans l’éditeur de mise en page.

Réponse (cherchez avant de regarder !) : ici

(14)

3 : Les événements et les listeners

https://openclassrooms.com/fr/courses/2023346-creez-des-applications-pour- android/2024698-les-widgets-les-plus-simples#/id/r-2024697

Les objets « listener » et les interfaces pour les définir

• Pour détecter les événements, on ajoute (on « set ») un objet « listener » sur le widget qui intercepte l’événement.

• Par exemple :

refBtn.setOnClickListener( new View.OnClickListener() { … } )

• La syntaxe utilisée est celle des classes imbriquées Java (nested class). OnClickListener est une classe imbriquée dans la class View, en l’occurrence une inteface. -> Sur la classe View : ici.

• On passe en paramètre un objet View.OnClickListener qui est une interface. Donc concrètement, il faudrait créer une classe qui implémente l’interface et ses méthodes et il faudrait passer en paramètre une instance de cette nouvelle classe.

• On peut aussi plus simplement faire un new de l’interface : ça fait la même chose. C’est la technique des classes anonymes. Du coup, il faut coder l’implémentation des

méthodes de l’interface ce qu’on fait directement à la suite entre { … } Les interfaces pour définir les objets « listener »

• Les interfaces des objets listener sont dans la classe View

• View.OnClickListener : pour un clic bouton

• View.OnLongClickListener : pour un clics qui dure longtemps.

• View.OnKeyListener : pour l'appui sur une touche.

• Etc.

• Doc : -> Sur la classe View : ici. Chercher « OnClickListener ». On peut ensuite cliquer dessus.

(15)

Les méthodes à implémenter dans les interfaces : les callback

• Les interfaces proposent-imposent des méthodes à implémenter.

• Ces méthodes, dans un listener, sont appelées de façon général « callback » o View.OnClickListener contient la méthode void onClick(View vue).

o View.OnLongClickListener contient la méthode boolean onLongClick(View vue).

o View.OnKeyListener contient la méthode boolean onKey(View vue, int code, KeyEvent event).

o View.OnTouchListener contient la méthode boolean onTouch(View vue, MotionEvent event).

o Etc.

• Certains callback retournent « true » quand l’action est effectuée, false si elle est encore en cours.

• Exemples :

o https://developer.android.com/reference/android/view/View.OnClickListener o https://developer.android.com/reference/android/view/View.OnLongClickListener o https://developer.android.com/reference/android/view/View.OnTouchListener

Les méthodes pour attacher un listener à un élément d’écran

• Chaque interface correspond à une méthode permettant d’attacher l’interface (passé en paramètre) à un élément d’écran (une vue).

• void setOnClickListener(View.OnclickListener)

• void setOnLongClickListener(View.OnLongClickListener)

• void setOnKeyListener (View.OnKeyListener)

• etc.

• Doc : -> Sur la classe View : ici. Chercher « setOnClickListener ». On peut ensuite cliquer dessus.

(16)

Technique de code - 1

• On peut écrire, mais on évite : public class MainActivity extends Activity

implements View.OnClickListener, View.OnTouchListener {

private Button button = null;

@Override

public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState);

setContentView(R.layout.main);

button = (Button) findViewById(R.id.boutton);

button.setOnTouchListener(this);

button.setOnClickListener(this);

}

@Override

public boolean onTouch(View v, MotionEvent event) { /* Réagir au toucher */

return true;

}

@Override

public void onClick(View v) { /* Réagir au clic */

} }

• Le problème est qu’on a implémenter une unique méthode onTouch() et onClick() pour tous les boutons.

• L’intérêt de cet exemple est de comprendre la syntaxe Java de l’usage des interfaces.

(17)

• On utilise cette méthode :

public class MainActivity extends Activity

{ ...

button.setOnClickListener(new View.OnClickListener() { @Override

} }) ; }

o On n’a plus besoin que le MainActivity implémente les interfaces.

o On attache un listener à un bouton, par exemple.

o View.OnClickListener( ) { } est la description d’une classe sans nom (anonyme) implémentant l’interface View.OnClickListener( ). Le code de cette classe est entre les { }. Etant donné qu’on part d’une interface, on doit au moins coder les méthodes des interfaces.

o new View.OnClickListerner() est l’instanciation d’un objet de cette classe anonyme.

Cet objet est passé en paramètre au setOnClickListener qui s’applique au button.

o Ainsi le button est associé à un listener.

(18)

• C’est le même principe que la 2, mais on met le « listener » dans un objet qui sera un attribut de l’activité (la MainActivity ici).

• Ensuite, cet attribut peut être utilisé comme paramètre dans un setListener ( ) public class MainActivity

extends Activity {

private OnClickListener clickListenerBouton = new View.OnClickListener() {

@Override

} };

...

button.setOnClickListener( clickListenerBouton ) ; }

o C’est utile si 2 widget partagent le même listener (donc réagissent de la même manière) : ça factorise le code.

o Le défaut est qu’à la lecture il faut faire le lien entre l’objet passer en paramètre au setListener et sa définition initiale.

(19)

Les raccourcis

• Dans Android Studio, l’IDE propose de compléter les méthodes automatiquement quand on commence à les saisir.

• Il crée aussi automatiquement le contenu de base d’une classe anonyme issue d’une interface.

(20)

TP 4 : IMC avec événements On reprend le TP3 :

• Dans un premier temps on gère le bouton « calculer l’IMC ». La formule pour calculer l'IMC est poids (en kilogrammes) / taille au carré (en metres) : on va d’abord gérer le bouton qui calcul l’IMC et affiche un message avec le poids, la taille et l’IMC. A terme, le bouton de calcul ne sera accessible que si des valeurs ont été saisies. Pour le moment, on ne vérifie pas si la saisie a été faite pour faire le calcul. Par contre, si les valeurs saisies sont nulles, on envoie un Toast !

• Dans un second temps, on affiche le message de la « mégafonction ». Quelque chose du genre : OK si l’IMC <30 et PAS OK si l’IMC > 30. Pour faire ça, on se dotera d’un classe interne Imc qui permet de créer un objet IMC à partir de la taille et du poids et qui permet de récupérer le message du bouton de calcul de l’IMC (premier temps) et de récupérer le message de la mégafonction

• Dans un troisième temps, on gère le bouton RAZ. Le bouton RAZ permet aussi de réafficher le message d’origine.

• Ensuite, il faudra gérer toutes les subtilités : - le changement d’unité met à jour les données saisies. – l’absence de saisie de valeur interdit bloque l’usage des fonctions

(21)

4 : Le layout (layout = mise en page) Principe général

https://developer.android.com/guide/topics/ui/declaring-layout

https://openclassrooms.com/fr/courses/2023346-creez-des-applications-pour- android/2024892-organiser-son-interface-avec-des-layouts#/id/r-2030733

• Une activité (une fenêtre) est un Layout (ou ViewGroup) qui contient des Layout ou des Widget (ou View par abus de langage).

• Cette organisation forme un arbre. Un Widget est une feuille : il n’a pas d’enfant.

• Principe de code : on évite que l’arbre ait une trop grande hauteur : on évite qu’un layout ait un grand-père layout !

Vocabulaire et notions

• La première balise XML de nos activités est une balise layout.

• Distinction layout - widget

o Un widget est un élément de base de l’écran qui permet d’afficher du contenu et d’interagir. Un widget fournit du contenu.

o Un layout s’occupe de la mise en page : la position dans l’écran, la taille des éléments, etc.

• Distinction View - ViewGroup

o Elle reprend la distinction layout – widget.

o Layout ---I> ViewGroup ---I> View o TextView ---I> View

o Les widget sont des TextView (TextView, EditView, CheckBox, Button, etc.) o Les Layout sont des ViewGroup

• Les 5 différents Layout (cliquer sur le nom pour avoir la doc) : o Il n’y a pas de class Layout, mais des Layout spécifiques :

o 1 : LinearLayout : les éléments sont les uns à la suite des autres, horizontalement ou verticalement : <LinearLayout android :orientation=« vertical »>

o 2 : RelativeLayout : les éléments sont disposées les uns par rapport aux autres ou disposées par rapport aux bordures de l’écran, comme s’ils étaient aimantés.

o 3 : TableLayout : les éléments sont disposées comme dans un tableau.

o 4 : FrameLayout :

o 5 : GridLayout : version plus élaborée de la table.

o AbsoluteLayout (deprecated) : chaque éléments est positionné avec ses coordonnées.

(22)

4.1 : LinearLayout

https://developer.android.com/guide/topics/ui/layout/linear

https://openclassrooms.com/fr/courses/2023346-creez-des-applications-pour- android/2024892-organiser-son-interface-avec-des-layouts#/id/r-2024782 Base : orientation vertical

<LinearLayout

xmlns:android="http://schemas.android.com/apk/res/android"

android:orientation="vertical"

android:layout_width="match_parent"

android:layout_height="match_parent" >

• orientation vertical : les widgets se placent l’un en dessous de l’autre

• Si le height du premier widget ="match_parent", alors il s’étale sur toute la hauteur.

• En général, le height des widget ="wrap_content"

• Ensuite on joue sur padding et margin orientation horizontal

• permet d’avoir les widget les uns à côté des autres, et pas en dessous.

• Si le height du deuxième widget ="match_content", il prendra toute la hauteur. Et le premier widget à côté ne prendra que la taille nécessaire si le height ="wrap_content".

gravity et layout_gravity

• Ces attributs peuvent valoir bottom, top, right, left, center ou un mixte de 2 : bottom|right par ex.

• layout_gravity positionne le widget par rapport à son layout

• https://developer.android.com/reference/android/widget/LinearLayout.LayoutParams#at tr_android:layout_gravity

• gravity positionne le contenu du widget (le texte par exemple) par rapport à son widget.

weight

• Ce attribut permet de définir le poids relatif en taille de chaque widget dans leur layout.

On peut mettre 1, 2, 3 par exemple. On peut aussi donner des valeurs dont la somme fait 100 : 30, 40, 30 pour avoir une répartition des taille parfaitement contrôlée. Le calcul est un peu étrange (il est inversé ! à tester !).

(23)

TP 5 : IHM du projet IMC, v2

• Le but est d’obtenir le résultat suivant :

• On part du résultat du TP3 : code XML : ici

• Faites les modifications pour arriver au résultat attendu

• Principe de code : on évite que l’arbre ait une trop grande hauteur : on évite qu’un layout ait un grand-père layout !

Détails :

(24)

4.2 : RelativeLayout

https://developer.android.com/guide/topics/ui/layout/relative

• C’est un Layout un peu difficile à utiliser mais performant en terme de ressource.

Attributs de position relative par rapport au layout :

• De base, le texte se positionne en haut à gauche. Ensuite, on adapte : o layout_centerInParent="true"

o layout_centerHorizontal="true"

o android:layout_centerVertical="true"

o layout_alignParentBottom="true"

o android:layout_alignParentTop="true"

o android:layout_alignParentLeft="true"

o android:layout_alignParentRight="true"

Attributs de position relative par rapport à un autre widget

• De base, le texte se positionne en haut à gauche. Ensuite, on adapte : o layout_below = "@id/uneBalise" // en dessous

o layout_above = "@id/uneBalise" // au-dessus o layout_toRightOf = "@id/uneBalise" // à droite o layout_toLeftOf = "@id/uneBalise" // à gauche

o layout_alignBottom = "@id/uneBalise" // aligner le plancher o layout_alignTop = "@id/uneBalise" // aligner le plafond o layout_alignLeft = "@id/uneBalise" // aligner le bord gauche o layout_alignRight = "@id/uneBalise" // aligner le bord droit

Subtilité de référence : @id+

• Pour faire référence à une vue qui n’existe pas encore (qui viendra après), on écrit :

@id+/

(25)

• Le but est d’obtenir le même résultat qu’au TP5 mais avec un RelativeLayout.

• Du coup, il n’y a plus de layout dans un layout ! Détails :

(26)

4.3 : Autres layouts

• LinearLayout et RelativeLayout sont les layouts les plus communs.

• Mais il existe d’autres layout (et n’oubliez pas qu’un layout peut s’appliquer à tout l’écran ou une certaines vues de l’écran seulement).

o WebView : pour afficher des pages web -> ici

o TableLayout : pour placr les éléments comme dans un tableau -> ici o FrameLayout : -> ici

o ScrollLayout : pour faire défiler le contenu d’une vue -> ici

• On peut aussi construire son layout avec un Adapter. -> ici. C’est utilisé avec : o RecyclerView : -> ici (version avancée de ListView et de GridView)

o ListView : -> ici o GridView : -> ici

(27)

5 : Ressources - inflater Présentation

• Les ressources se trouvent dans App/Res

• Elles permettent de factoriser du code.

• Un fichier de ressources est écrit en XML

• Il ressemble à :

<?xml version="1.0" encoding="utf-8"?>

…

</resources>

• On peut utiliser l’éditeur graphique : préférable pour les images (drawable)

• On peut travailler directement en XML : préférable pour le texte et les couleurs (values) Editeur graphique

• Pour l’utilisation de l’éditeur graphique : on se met sur le dossier de ressources (drawable ou values) -> bouton droit / new values-drawable ressource file, puis intuitivement…

• Pour des détails d’utilisation, voir ici : http://bliaudet.free.fr/IMG/txt/4517166-2-0-TP- 3-complet.js en cherchant « ressources » dans le texte. Et ici :

http://bliaudet.free.fr/IMG/txt/4517166-2-0-TP-2-complet.js en cherchant « color » dans le texte.

Rappels détaillées sur les ressources

• Pour une présentation détaillées des ressources, voir ici :

http://bliaudet.free.fr/IMG/pdf/intro_basique.pdf en cherchant « les ressources » dans le texte.

(28)

Technique Android : fichier R et ressources XML

• Dans le fichier Strings

<string name="hello">Hello World</string>

</resources>

• En XML on écrit : @string/hello

• En java on écrit : R.strings.hello

Contenu d’une chaine de caractères : apostrophe et guillemets

• Valeur pas entre guillemets, apostrophe et guillemets escapés :

<string name="monExemple">Texte de la chaîne qui s\'appelle

\"monExemple\"</string>

• Valeur entre guillemets, apostrophe non escapée, guillemets escapés :

<string name="monExemple">"Texte de <b>la chaîne</b> qui s'appelle

\"monExemple\""</string>

(29)

Contenu d’une chaine de caractères avec du HTML

• On peut mettre du HTML dans une ressource. La gestion XML ne pose pas de problème.

• Le HTML est pris en compte à l’affichage

<string name="accueil"><b>Hello</b>. What\'s your name ?</string>

• Si on veut utiliser la ressource en Java, c’est plus compliqué, mais pas très utile !

• Exemple de solution ici : https://openclassrooms.com/fr/courses/2023346-creez-des- applications-pour-android/2025243-les-autres-ressources#/id/r-2031022

(30)

Contenu d’une chaine de caractères avec des variables

• On veut que la String puisse recevoir des paramètres variables.

• Par exemple : on veut afficher : « Bonjour Toto. Vous avez 22 ans ».

• Dans ce cas, ça fonctionne uniquement en Java. Le XML ne permet pas de faire rentrer les valeurs variables.

En XML, on déclare la ressource :

<string

name="hello">Bonjour %1$s, vous avez %2$d ans </string>

</resources>

• %1$s veut dire : première variable, string

• %2d veut dire : deuxième variable, entier En Java, on utilise la ressource :

Resources res = getResources();

String chaine = res.getString(R.string.hello, "Toto", 22);

En général, en Java pour formater :

String s = String.format("Bonjour $s. Vous avez $d ans", "Toto", 22);

(31)

Les couleurs

• On a un fichier de ressources pour les couleurs.

Exemple de définition d’un style en XML

</resources></style>

Exemple d’utilisation d’un style en XML

<Button ...

android:background="@color/AQUA"

...

/>

Exemple d’utilisation d’un style en Java

refMonBouton = (TextView) findViewById(R.id.refMonBouton);

refMonBouton.setBackgroundResource(R.color.AQUA) R.color

• https://developer.android.com/reference/android/R.color

• A noter qu’on ne peut pas écrire : R.color.white.

(32)

Les drawables

• Pour des détails d’utilisation, voir ici : http://bliaudet.free.fr/IMG/txt/4517166-2-0-TP- 3-complet.js en cherchant « drawable » dans le texte.

• Pour une présentation détaillées des ressources, voir ici :

http://bliaudet.free.fr/IMG/pdf/intro_basique.pdf en cherchant « drawable» dans le texte.

• Autres description détaillée : https://openclassrooms.com/fr/courses/2023346-creez-des- applications-pour-android/2025243-les-autres-ressources#/id/r-2025080

(33)

5.1 : Les styles Présentation

• Les styles permettent de définir une charte graphique qu’on applique à tous les widgets de l’application.

• Par exemple, tous les boutons auront le même style.

• La gestion des styles se fait avec les ressources

• Le fichier styles.xml se trouve dans res/values Exemple

définition d’un style en XML

• Dans le fichier styles.xml, on ajoute :

<item name="android:background">@color/AQUA</item>

</style>

o Le nom du parent n’est pas obligatoire.

utilisation d’un style en XML

• Dans le fichier du res/layout on ajoute :

<Button

style="@style/monBouton"

android:id="@+id/activity_game_btn_reponse4"

android:layout_width="match_parent"

...

/>

utilisation d’un style en Java

• Un style ne s'applique pas de manière dynamique en Java, il faut préciser le style à utiliser dans le constructeur.

• Constructeur d’une View : public View (Context contexte, AttributeSet attrs).

• Pour les détails : regardez ici, et cherchez « public constructors » Button bouton = new Button (this, R.style.monBouton);

(34)

Format général d’un fichier de style

<item name="propriete_1">valeur_de_la_propriete_1</item>

</style>

</style>

</resources>

o Ici, on définit un premier style : nomStyle1

o Puis un deuxième style : nomStyle2 qui hérite de nomStyle1. Il peut le compléter (propriete_3) ou le redéfinir (propriete_1).

o Doc : https://developer.android.com/guide/topics/resources/style-resource

(35)

• Sur une version antérieure du TP IMC, ajoutez des styles.

TP 8 : projet éditeur

• L’objectif est d’avoir une page dans laquelle on peut saisir un texte (zone édition) qui s’affiche en dessous (zone prévisualisation).

• On peut mettre en gras, en italique ou souligner. Choisir une couleur parmi 3. Mettre des smileys. Cacher certaines parties.

• Les détails sont ici :

https://openclassrooms.com/fr/courses/2023346-creez-des-applications-pour- android/2025483-tp-un-bloc-notes

(36)

(37)

5.2 : Les animations Présentation

• Une animation est une ressource qui se définit dans res/anim.

• Les animations ne sont pas des données (comme les strings ou les styles) mais des ressources indépendantes comme les drawables.

• Une animation est décrite par un état de départ pour une vue (un widget ou un layout) et un état d'arrivée. Par exemple on part d'une vue visible pour qu'elle devienne invisible.

• Pour définir une animation, on se donne un repère en X et Y. Le 0-0 est en haut à gauche. Les X augmente vers la droite, les Y augmente vers le bas.

4 animations de base

• Transparence <alpha> : faire apparaître ou disparaître une vue.

• Taille <scale> : agrandir ou de réduire une vue.

• Mouvement <translate> : faire subir une translation à une vue

• Rotation <rotation>: faire tourner une vue autour d'un axe.

Réréfences

• Android : https://developer.android.com/guide/topics/resources/animation-resource

• OCR : https://openclassrooms.com/fr/courses/2023346-creez-des-applications-pour- android/2025243-les-autres-ressources#/id/r-2025104

Codage XML

• On va créer des fichiers dans res/anim : il faut commencer par créer le dossier anim

• Sur le dossier res/anim : bouton droit/new/animation ressource file : anim_test

<setxmlns:android="http://schemas.android.com/apk/res/android">

</set>

(38)

Exemples de syntaxe (issu de la documentation Android -> ici)

<set xmlns:android="http://schemas.android.com/apk/res/android"

android:interpolator="@[package:]anim/interpolator_resource"

android:shareInterpolator=["true" | "false"] >

<alpha

android:fromAlpha="float"

android:toAlpha="float" />

<scale

android:fromXScale="float"

android:toXScale="float"

android:fromYScale="float"

android:toYScale="float"

android:pivotX="float"

android:pivotY="float" />

<translate

android:fromXDelta="float"

android:toXDelta="float"

android:fromYDelta="float"

android:toYDelta="float" />

<rotate

android:fromDegrees="float"

android:toDegrees="float"

android:pivotX="float"

android:pivotY="float" />

<set>

...

</set>

(39)

Application : <alpha>

XML

• On crée le fichier res/anim/anim_progressif de contenu :

<!-- alpha

fromAlpha : 0.0 : élément non affiché toAlpha : 1.0 : élément affiché au maximum duration : 3000 : 3 secondes de transition -->

<alpha

android:fromAlpha="0.0"

android:toAlpha="1.0"

android:duration="3000"

/>

</set>

• On fait le lien dans le layout : sur une balise, par exemple l’EditText de la taille et la Button Raz, on ajoute un attribut layoutAnimation

android:layoutAnimation="@anim/anim_progressif"

(40)

Java

• Classes : o Animation o AnimationUtils o View

• Méthodes :

o animation.setDuration

o Animation AnimationUtils.loadAnimation (contexte, R.animation) o animation.setDuration

o view.startAnimation(animation)

• Principes :

o on crée une animation avec AnimationUtils.loadAnimation()

o on starte l’animation avec un startAnimation(animation) appliquée à la vue (le widget) qui porte l’animation XML.

• Remarque : le contexte est le même pour tous les widgets.

• On peut faire les 2 opérations en une seule instructions.

• Toutefois, si on veut paramétrer l’animation (setDuration() par exemple), il faut avoir un objet animation. Ici, le Bouton réagit plus lentement que l’EditTaille.

Animation animationProgressif = AnimationUtils.loadAnimation(

refBtnRaz.getContext(), R.anim.anim_progressif );

animationProgressif.setDuration(10000);

refBtnRaz.startAnimation(animationProgressif);

refEditTaille.startAnimation(

AnimationUtils.loadAnimation(

this.refEditTaille.getContext(), R.anim.anim_progressif)

);

(41)

Application : <scale> <translate>

XML

• On crée le fichier res/anim/anim_bouger avec le contenu ci-dessous.

• A noter la présence de android :interpolator qui crée un effet.

• Il y a de nombreuses interpolations possibles.

• On peut les tester, et tester sans interpolation.

• https://openclassrooms.com/fr/courses/2023346-creez-des-applications-pour- android/2025243-les-autres-ressources#/id/r-2031236

android:interpolator = "@android:anim/bounce_interpolator"

>

<!-- agrandir

Scale : 1.0 valeur actuel - 0.0 : petit - 3.0 : grand pivot : 200% : extrémité - souvent 50% 50%

-->

<scale

android:fromXScale="0.0"

android:fromYScale="0.0"

android:pivotX="200%"

android:pivotY="0%"

android:toXScale="1.0"

android:toYScale="1.0"

/>

!-- déplacer

position en %age - 0% valeur actuelle.

-->

<translate

android:fromXDelta="200%"

android:fromYDelta="0%"

android:toXDelta="0%"

android:toYDelta="0%"

/>

</set>

Java XML

• On crée et on start l’animation sur le Check avec une durée de 5 secondes, par exemple.

(42)

Application : <rotation>

XML

• On crée le fichier res/anim/anim_rotation avec le contenu ci-dessous.

• A noter la présence de android :repeatMode qui crée un effet permet de répéter l’animation : ici la rotation. C’est dans le set pour que ça s’applique à toutes les animations (ici une seule).

• android :repeatCount permet de dire combien de fois on répète, en plus du tour de base.

android:repeatMode="restart"

>

<!--

pivot : position du centre de rotation : 50-50 : milieu du widget -->

<rotate

android:fromDegrees = "0"

android:toDegrees = "360"

android:pivotX = "50%"

android:pivotY = "50%"

android:duration="2000"

android:repeatCount="2"

/>

</set>

Java XML

• On crée et on start l’animation sur le Bouton Calcul dans le Java.

• On peut changer la duration dans le java.

• On peut tester : pivotX à 100 et pivotY à 0

(43)

Application : animation du Layout complet : <LayoutAnimation>

Objectifs

• On veut appliquer une animation à tous les éléments du layout XML

• On crée le fichier res/anim/anim_layout avec le contenu ci-dessous.

• On n’a pas de balise <set> mais une unique balise <LayoutAnimation>

<!--

delay : delai de propagation entre les enfants : 0% immédiat, 100% très lent animationOrder : ordre de traitement des éléments : random, aléatoire animation : le lien vers l'animation mise en oeuvre

-->

<layoutAnimation xmlns:android="http://schemas.android.com/apk/res/android"

android:delay="10%"

android:animationOrder="random"

android:animation="@anim/anim_rotation"

/>

Java

Classe : LayoutAnimationController

Méthode : AnimationUtils.loadLayoutAnimation( contexte, R.animLayout) On crée non plus une animation mais un layoutAnimationController

Ensuite on sette ce controller à l’objet view de notre layout.

On commence avec un setDelay à 0 : tous les mouvements sont synchronisés.

Ensuite, on passe à 0.1 (il faut le caster en float) Le refLayout est un objet de la classe LinearLayout.

LayoutAnimationController animationLayout = AnimationUtils.loadLayoutAnimation(

refLayout.getContext(), R.anim.anim_layout );

animationLayout.setDelay((float) 0.0); // 0.1 = 10%

refLayout.setLayoutAnimation(animationLayout);

(44)

6.1 : Widget+ : Les boites de dialogue Principes

• Vieille méthode : showDialog() : elle est dépréciée.

• On passe aujourd’hui par la classe AlertDialog et la classe AlertDialog.Builder

• La classe permet de : o donner un titre à la boite o mettre un message o définir un bouton ok o définir un bouton annuler o afficher le message o et bien d’autres choses…

• Sur les boutons ok et annuler, on peut ajouter une gestion d’événement

Références

• Android : https://developer.android.com/reference/android/app/AlertDialog.Builder

• Android : https://developer.android.com/guide/topics/ui/dialogs.html

• StackOverflow : https://stackoverflow.com/questions/2115758/how-do-i-display-an- alert-dialog-on-android

• OCR : https://openclassrooms.com/fr/courses/2023346-creez-des-applications-pour- android/2025852-des-widgets-plus-avances-et-des-boites-de-dialogue#/id/r-2031751

(45)

Exemples Où ?

• On va mettre une boite de dialogue dans la méthode onClick du listener du boutonRaz, juste pour tester.

refBtnRaz.setOnClickListener(new View.OnClickListener() { @Override

public void onClick(View v) { AlertDialog.Builder alert = ...

Principes

• On instantie un objet de la classe AlertDialog.Builder et on sette les attributs.

• Pour le « PositionButton », on passe en paramètre un DialogInterface.OnClickListener.

C’est une interface. La syntaxe utilisée est celle des classes imbriquées Java (nested class).

• A noter que l’EDI Android propose un remplissage de code automatique dès qu’on commence à saisir le new Dialog…

• Ensuite, il reste à coder le contenu de onClick : ici, un simple Toast, pour le test.

• Le paramètre which permet de savoir quelle bouton est cliqué (ok : 1, annuler : 2, etc.).

Version 1, écriture classique

AlertDialog.Builder alert = new AlertDialog.Builder(MainActivity.this);

alert.setTitle("Ma boite de dialogue");

alert.setMessage("Faites un choix");

alert.setPositiveButton("OK", new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialog, int which) {

Toast.makeText(MainActivity.this, "Choix OK", Toast.LENGTH_SHORT).show();

} });

alert.setNegativeButton("Annuler", new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialog, int which) {

Toast.makeText(MainActivity.this, "Choix Annuler", Toast.LENGTH_SHORT).show();

} });

alert.show();

(46)

Version avec un objet anonyme du AlertDialog.Builder

Ici, on passe par une instance anonyme (l’objet « alert » de la version précédente).

On peut ainsi appeler les méthodes à la suite du new dans une syntaxe compacte.

new AlertDialog.Builder(MainActivity.this) .setTitle("Ma boite de dialogue") .setMessage("Faites un choix") .setPositiveButton("ok", null)

.setNegativeButton("annuler", new DialogInterface.OnClickListener() { @Override

public void onClick(DialogInterface dialog, int which) {

Toast.makeText(MainActivity.this, "Choix Annuler", Toast.LENGTH_SHORT).show();

} }) .show();

(47)

6.2 : Widget+ : Date et heure

• Android : https://developer.android.com/reference/android/widget/DatePicker.html

• Exemples : https://www.tutlane.com/tutorial/android/android-datepicker-with-examples

• OCR : https://openclassrooms.com/fr/courses/2023346-creez-des-applications-pour- android/2025852-des-widgets-plus-avances-et-des-boites-de-dialogue#/id/r-2031801

Exemple

• Le code ci-dessous est placé à la toute fin du projet IMC, sous le widget TextResultat

• Le code est adapté à un RelativeLayout (d’où le below).

<DatePicker android:id="@+id/datePicker1"

android:layout_width="wrap_content"

android:layout_below="@id/refTextResultat"

android:layout_centerHorizontal="true"

android:background="#FFFFFF"

android:headerBackground="@color/colorPrimary"

/>

• De ce fait, le widget TextResultat est adapté :

android:lines="5"

Adaptation : android :datePickerMode Différents mode d’affichage

android:datePickerMode="calendar"/>

android:datePickerMode="spinner"/>

android:datePickerMode="spinner"

android:calendarViewShown="false"/>

(48)

5.3 : Menu d’options (menu d’application) Principes d’interface utilisateur

• La question des menus est relève de l’usage de l’interface utilisateur. Son principe est que cette organisation sera cachée dans un sommaire plus ou moins facile à utiliser.

• Ce qui peut sembler clair au développeur peut sembler obscur à l’utilisateur.

• Ce qui compte, c’est si les utilisateurs se servent des fonctionnalités proposés.

• De ce fait, les techniques d’accès aux fonctionnalités évoluent pour s’adapter aux usages des utilisateurs.

• Il faut donc regarder ce que sont les usages au moment où on code et choisir de mettre en œuvre ce qui semble être les meilleurs usage du moment.

Présentation générale

• 3 types de menu :

o le menu d’options (bouton du téléphone ou widget « évident » dans l’application) o le menu contextuel (long clic ou clic droit sur un widget)

o le menu popup

• Un menu peut contenir un menu

• On gérer un menu en Java et/ou en XML

Présentation du menu d’options (menu d’application)

• https://openclassrooms.com/fr/courses/2023346-creez-des-applications-pour- android/2025954-gestion-des-menus-de-l-application#/id/r-2031864

• https://developer.android.com/guide/topics/ui/menus#options-menu

• Le menu d’options est rattaché à l’activité en cours (l’écran). Il permet de placer les actions qui ont un impact global sur l'application, telles que "Recherche", "Composer un e-mail", "Paramètres", etc.

(49)

Menu d’option XML : res/menu

• Le fichier XML se met dans res/menu : il faut d’abord créer un répertoire menu.

• Balise <menu> et balises <item>

La balise <menu>

• On crée un fichier XML : il contient par défaut une balise <menu>

</menu>

La balise <item>

• La balise <item> peut-doit contenir plusieurs attributs : o android:id : pour lancer la fonction correspondante o android:icon : pour mettre une icon

o android:title : pour mettre un texte (si il n’y a pas d’icône) o android:titleCondensed : pour mettre un texte comprimé o android:enable : pour désactiver l’item

o android:checkable : pour rendre l’item cochable.

o android:showInAction : joue sur l’affichage. A tester selon les machines (à noter : always, never, ifRoom)

• Tous les attributs :

o https://developer.android.com/guide/topics/resources/menu-resource

• La balise <item> peut contenir une balise <menu> : pour gérer des sous-menus.

(50)

Icones

• https://developer.android.com/studio/write/vector-asset-studio

• Les icones se trouvent dans app/res/drawable

• Ce sont des fichiers qui commencent par ic_

• Pour ajouter une nouvelle icône : o app/res/bouton droit/New/vector asset o Asset type : Clip Art (c’est fait par défaut)

o Sélectionner le bouton rectangulaire Clip Art : une fenêtre d’icônes s’ouvre o Sélectionner une icône + ok

o Donner le nom souhaité + next + finish

• Ca marche plus ou moins dans l’émulateur !

(51)

Événement

https://developer.android.com/guide/topics/ui/menus#options-menu

https://openclassrooms.com/fr/courses/2023346-creez-des-applications-pour- android/2025954-gestion-des-menus-de-l-application#/id/r-2031937

• Exemple :

@Override

public boolean onOptionsItemSelected(MenuItem item) { // Handle item selection

switch (item.getItemId()) { case R.id.new_game:

newGame();

return true;

case R.id.help:

showHelp();

return true;

default:

return super.onOptionsItemSelected(item);

} }

• Ici on fait appel à une fonction newGame() qui pourrait ouvrir une autre activité.

• Pour tester le code simplement, on peut faire un Toast : Toast.makeText(

MainActivity.this, "help ic_help", Toast.LENGTH_LONG ).show();

(52)

Exemple de Menu : TP 1

• Chargez le dossier main sur le site.

• Créez un projet vide "Test Menus" puis fermez-le.

• Remplacez le dossier TestMenus/src/main par ce dossier "main" téléchargé.

• Ouvrez "Test Menus" avec Android.

Exemple de Menu : TP 2

• Créez le premier exemple de menu qui se trouve ici :

• https://developer.android.com/guide/topics/ui/menus#options-menu

• Il contient les items suivants :

<item android:id="@+id/new_game"

android:icon="@drawable/ic_new_game"

android:title="@string/new_game"

android:showAsAction="always"/>

<item android:id="@+id/help"

android:icon="@drawable/ic_help"

android:title="@string/help" />

• Rajoutez plusieurs items de jeu

• Créez un sous menu

• Ajoutez les string nécessaires.

• Mettez une icône sur les items.

• Mettez un Toast en action sur les menus.

(53)

5.4 : Menu contextuel Présentation générale

• 3 types de menu :

o le menu d’options (bouton du téléphone ou widget « évident » dans l’application) o le menu contextuel (long clic ou clic droit sur un widget)

o le menu popup

• Un menu peut contenir un menu

• On gérer un menu en Java et/ou en XML Présentation du menu contextuel

• Un menu contextuel propose des actions qui affectent le contenu ou le cadre contextuel sélectionné.

• https://developer.android.com/guide/topics/ui/menus#context-menu

Exemple de Menu contextuel : TP android

• Testez le code android : https://developer.android.com/guide/topics/ui/menus#context- menu

(54)

5.5 : Autres menus Popup Menu

Présentation

• Genre de menu contextuel

• https://developer.android.com/guide/topics/ui/menus#PopupMenu Action Bar

Présentation

• Barre de titre étendue

Rappel du principe de l’interface utilisateur

• La question des menus est relève de l’usage de l’interface utilisateur. Son principe est que cette organisation sera cachée dans un sommaire plus ou moins facile à utiliser.

• Ce qui peut sembler clair au développeur peut sembler obscur à l’utilisateur.

• Ce qui compte, c’est si les utilisateurs se serve des fonctionnalités proposés.

• De ce fait, les techniques d’accès aux fonctionnalités évoluent pour s’adapter aux usages des utilisateurs.

• Il faut donc regarder ce que sont les usages au moment où on code et choisir de mettre en œuvre ce qui semble être les meilleurs usage du moment.