Interfaces

• La mise en place d'une interface peut se faire de deux

façons :
− Par description de l'interface dans des fichiers
ZEMALI el amine XML

− Par programme

Extensible Markup Language Pourquoi xml?

La raison de cette approche, à savoir l'utilisation de XML
langage de balisage extensible pour tout ce qui peut être considéré comme orienté
conception, est que l'utilisation de XML libère les membres
de votre équipe de développement d'applications qui
Extensible: (pensez "personnalisable") Vous pourriez conçoivent:
créer votre propre ensemble de balises XML pour n'importe  la convivialité de votre application,
quel but que vous souhaitez.  l'accès aux fonctionnalités,
 l'interface utilisateur,
 les styles,
C'est un langage de balisage, car il utilise de simples "balises"
 le thème,
pour définir ce que vous voulez faire.
 les graphiques, etc.,
de devoir apprendre (c'est-à-dire, comprendre) comment
Un autre langage de balisage appelé HTML, ou Hypertext fonctionne la programmation Java.
Markup Language, qui est utilisé pour créer des sites Web
Fonctionnalités Avancée
Quelques exemples de fonctionnalités avancées liées à la Vous pouvez également implémenter des fonctions de
conception Android que vous pouvez implémenter conception stratégiques moins avancées en utilisant XML, y
principalement à l'aide de «définitions» de balisage XML compris:
incluent principalement:  des valeurs constantes de chaîne (texte) pour votre
application,
 des graphiques multi-états,
 des constantes de valeurs entières (numériques),
 des éléments d'interface utilisateur personnalisés,
 des constantes de valeur état (booléen),
 des images, des animations,  les valeurs d'espacement d'écran (dimension) pour vos
 les menus d'options, les menus contextuels, conceptions d'interface utilisateur.
 les boîtes de dialogue, les boîtes de dialogue d'alerte,  Les tableaux, qui sont des collections de données utilisées
dans votre application (comme une simple base de
 les styles, les thèmes
données), peuvent également être créés et chargés avec
 et le manifeste de votre application. leurs valeurs de données, en utilisant des fichiers XML.

Fichier .XML
Le balisage XML est contenu dans de simples fichiers
Les fichiers XML qui décrivent une interface sont:
au format texte identifiés à l'aide de l'extension de
 placés dans le répertoire res/layout.
fichier .xml.
 référencés par R.layout.nom_du_fichierXML.
Les activités peuvent utiliser la méthode
Ces fichiers XML peuvent ensuite être lus ou setContentView(R.layout.nom_du_fichierXML)
"analysés" par le système d'exploitation Android, ou pour mettre en place l'interface décrite par un tel fichier.
le code Java de votre application, et transformés en Le bloc de base pour la création d'interfaces utilisateur
structures d'objet Java. est un objet View créé à partir de la classe View qui
occupe une zone à l'écran et est responsable du dessin et
de la gestion des événements.
 Forme générale d’un fichier XML
 En utilisant le vocabulaire XML d'Android, vous pouvez
Un document XML est constitué par des éléments ayant chacun une
rapidement concevoir des mises en page d'interface utilisateur balise de début, un contenu et une balise de fin.
et les éléments d'écran qu'elles contiennent, de la même
manière que vous créez des pages Web en HTML, avec une
Un document XML doit avoir exactement un élément racine (une
série d'éléments imbriqués. balise qui renferme toutes les autres balises). XML fait la distinction
entre les lettres majuscules et minuscules.
Chaque fichier layout doit contenir exactement un élément
Un fichier XML « bien formé » doit remplir les conditions suivantes :
racine, qui doit être un objet View ou ViewGroup. • un document XML commence toujours par un prologue
• chaque balise d'ouverture a une balise de fermeture ;
• toutes les balises sont complètement imbriquées.
Une fois que vous avez défini l'élément racine, vous pouvez
ajouter des objets layout en page ou des widgets
supplémentaires en tant qu'éléments enfants pour créer Un fichier XML est dit valide s'il est bien formé et s'il contient un lien
vers un schéma XML. Il est valide par rapport à ce schéma.
progressivement une hiérarchie View qui définit votre layout.

Forme générale d’un fichier XML Forme générale d’un fichier XML
<Classe_du_conteneur_principal
Un document XML commence toujours par un xmlns:android="http://schemas.android.com/apk/res
prologue qui décrit le fichier XML. /android"
propriétés du conteneur principal>

Ce prologue peut être minimal, par exemple: <Classe de conteneur ou d'élément d'interface
<?xml version="1.0"?> propriétés du conteneur ou de l'élément d'interface/>
…
Ou peut contenir d'autres informations, par exemple
<Classe de conteneur ou d'élément d'interface
l'encodage : <?xml version="1.0" encoding="UTF- propriétés du conteneur ou de l'élément d'interface/>
8" standalone="yes"?>
</Classe_du_conteneur_principal>
 View --- ViewGroup Par exemple, voici un Layout XML qui utilise un LinearLayout vertical
pour contenir un TextView et un Button:
Dans une application Android, l’interface utilisateur est <?xml version="1.0" encoding="utf-8"?>
construite à l’aide d’objets de type View et ViewGroup. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent" android:layout_height="match_parent"
android:orientation="vertical" >

View est la classe de base des widgets « composant <TextView android:id="@+id/text"

android:layout_width="wrap_content"
d'interface graphique interactifs » on cite comme android:layout_height="wrap_content"
exemples Champs de texte, Boutons, etc… android:text="Hello, I am a TextView" />

<Button android:id="@+id/button"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
ViewGroup est une sous-classe de View, fournit un android:text="Hello, I am a Button" />
conteneur invisible qui contient d'autres Views ou
</LinearLayout>
d'autres ViewGroups, et organise la manière dont sont
présents les composants. Après avoir déclaré votre layout au format XML, enregistrez le fichier avec
l'extension .xml dans le répertoire res / layout / de votre projet Android afin
qu'il soit correctement compilé.

Propriétés des éléments Identifiant (ID)

d’interface
Identifiant: Tout objet View peut être associé à un identifiant entier,
afin d'identifier de manière unique la vue dans l'arborescence.
Le symbole at (@) au début de la chaîne indique que
Lorsque l'application est compilée, cet ID est référencé en tant l'analyseur XML doit analyser et développer le reste de la
qu'entier, mais l'ID est généralement affecté dans le fichier XML de chaîne d'ID et l'identifier comme ressource d'ID.
présentation sous la forme d'une chaîne, dans l'attribut id. C'est un
attribut qui peut être associé à chaque élément décrit dans un fichier
XML, et permet de référencer l'objet créé dans d’autres fichiers Le signe plus (+) signifie qu'il s'agit d'un nouveau nom
XML
de ressource qui doit être créé et ajouté à nos ressources
Les éléments ne devant pas être référencés peuvent ne pas avoir (dans le fichier R.java).
d'identifiant.

La syntaxe d’un ID: android:id="@+id/mon_id" Il existe un certain nombre d'autres ressources

d'identification offertes par le framework Android.
Pour retrouver cet élément ont utilise la méthode
findViewById (R.id.mon_id).
Afin de créer des vues (views) et de les référencer à partir de l'application, La taille
un modèle commun est de:
1- Définissez une vue / un widget dans le fichier layout et Tous les éléments qui composent une interface
graphique doivent fournir une taille, grâce aux deux attributs :
attribuez-lui un identifiant unique:
 android:layout_height
 android:layout_width

Ces deux propriétés peuvent prendre 3 types de valeur :

 Une taille fixe : par exemple 30px (pixels).
 match_parent: indique à la vue de devenir aussi grande que
son groupe de vue parent permettra i.e L’élément occupe tout
2- Créez ensuite une instance de l'objet de vue et capturez la l’espace disponible chez son conteneur parent.
 wrap_content: indique à la vue de se dimensionner aux
à partir de layout (généralement dans la méthode dimensions requises par son contenu i.e. L’élément occupe la
onCreate ()): place nécessaire (la taille de son contenu).

Position
Gravité des éléments: Les éléments sont placé dans le
layout en haut et à gauche par défaut.
Pour positionner un élément autre part, on utilise l'attribut :
"android:gravity qui peut prendre différentes valeurs :
–android:gravity="top"
–android:gravity="bottom"
–android:gravity="left"
–android:gravity="right“
–android:gravity="center_horizontal"
–android:gravity="center_vertical"

Il est possible de combiner les valeurs grâce au symbole |

(touche 6 + Alt Gr) : android:gravity=“bottom|right"
Espacement
Les différents éléments créés sont par défaut serrés les
uns contre les autres.
On peut augmenter l’espacement à l’aide de la propriété
 android:padding (Marges internes)
 android:layout_margin (Marges externes)

Exemple:
android:padding="9px" (la valeur précise l’espace situé
entre le contour de l’élément et son contenu).
android:layout_margin="9px" (la valeur précise
l’espace situé entre le contour de l’élément et le contour
de ses voisins).
 Espacement Unités de mesure dans les fichiers XML
Il est aussi possible de créer un
décalage uniquement sur l'un Les dimensions des éléments d’interface (taille, marges,
des côtés du widget …) peuvent être exprimées en :

 en haut avec paddingTop ou – Pixels (px)

layout_marginTop – Pouces (in)
– Millimètres (mm)
 ou en bas avec – Points (pt) = 1/72 pouce
paddingBottom ou – Pixel à densité indépendante (dp) 1 dp= 1 pixel pour un
layout_marginBottom
écran de 160 dpi
 à gauche avec paddingLeft
– Pixel à taille indépendante (sp) relatif à la taille des
polices de caractères
ou layout_marginLeft,
à droite avec paddingRight
ou layout_marginRight, Dans les fichiers XML les unités sont exprimées sous la
forme : “30.5mm” ou “74px” …

Les conteneurs (les Layouts)

Les Conteneurs (les layouts)
Un layout est un objet, qui va contenir d'autres layouts et/ou les
Une mise en page définit la structure d'une interface utilisateur dans votre
éléments de l’interface graphique comme les boutons, les Textview
..... Et qui permet d'organiser la disposition de ces éléments sur
application, par exemple dans une activité. Tous les éléments de layout sont l'écran.
construits en utilisant une hiérarchie d'objets View et ViewGroup. Les layouts sont des classes qui héritent toutes d'une même classe
Une vue (view) est généralement quelque chose que l'utilisateur peut voir et parente, la classe ViewGroup.
interagir avec. Alors qu'un ViewGroup est un conteneur invisible qui définit la Il existe plusieurs types de layout :
structure de disposition pour View et d'autres objets ViewGroup,
 Linear Layout,
 Relative Layout,
 Table Layout,
 Absolute Layout
 Frame Layout
 List View
 Grid View
 ConstrainteLayout
chacun avec des caractéristiques différentes.
 LinearLayout
Linear Layout est un groupe de vues (ViewGroup) qui aligne tous les
éléments enfants (conteneurs ou widgets) appartenant à ce Layout
verticalement ou horizontalement.
Le choix de la direction se fait avec l'attribut android:
orientation. User name :

password:

Attributs de LinearLayout
Attribut Description
LinearLayout : Exemple
android:id C'est l'identifiant qui identifie de façon unique le layout Suivez les étapes suivantes pour modifier l'application Android
« Hello World » et pour montrer comment créer votre propre
android:baseline Cela doit être une valeur booléenne, "true" ou "false" et application Android en utilisant Linear Layout.
Aligned empêche le layout d'aligner les lignes de base de ses enfants.
android:baselineAlig Lorsque LinearLayout fait partie d'un autre layout alignée sur
nedChildIndex la ligne de base, il peut spécifier lequel de ses enfants doit être Etape Description
aligné sur la ligne de base.
1 Utiliserez Android Studio pour créer une application Android sous le
android:divider Ceci est à utiliser comme un diviseur vertical entre les
nom ‘Demo’ par exemple
boutons. Vous utilisez une valeur de couleur.
2 Modifiez le contenu par défaut du fichier res / layout /
android:gravity Ceci spécifie comment un objet doit positionner son contenu, activity_main.xml pour inclure quelques boutons dans le
à la fois sur les axes X et Y. conteneur linéaire (LinearLayout).
3 Exécutez l'application pour lancer l'émulateur Android et vérifier le
android:orientation Ceci spécifie la direction de l'arrangement. Vous utilisez résultat des modifications effectuées dans l'application.
"horizontal" pour une ligne, "vertical" pour une colonne.
android:weightSum Somme des poids de l'enfant
Exemple 1 Exemple 1
res/layout/activity_main.xml
MainActivity.java.

public class MainActivity extends Activity {

@Override
protected void onCreate(Bundle savedInstanceState)
{ super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}
}

Poids RelativeLayout
android: layout_weight Permet d’attribuer un permet de spécifier comment les
poids à élément en termes de la quantité d'espace vues enfants sont positionnées:
qu‘il doit occuper sur l'écran.
 les unes par rapport aux autres
Le poids par défaut est zéro. (par rapport aux éléments frères).

Un poids plus important permet de se développer  ou relatifs au parent.

pour remplir tout espace restant dans la vue parent.
 Attributs de RelativeLayout RelativeLayout
En utilisant RelativeLayout, vous pouvez:
 aligner deux éléments par une bordure droite
 mettre un en dessous d'un autre,
Attribut Description  centré sur l'écran,
android:id C'est l'identifiant qui identifie de façon unique le  centré à gauche, etc.
layout
android:gravity Ceci spécifie comment un objet doit positionner
son contenu, à la fois sur les axes X et Y. • Par défaut, toutes les vues enfants sont dessinées en haut à
gauche de layout. Vous devez donc définir la position de
android:ignoreGravity Cela indique quelle vue ne devrait pas être chaque vue à l'aide des différentes propriétés disponibles dans
affectée par la gravité. RelativeLayout.LayoutParams

• Dans ce type de relation on lie un élément à son conteneur à

l’aide d’un ensemble d’attributs.

Positionnement relatif au conteneur

Attribut Description
android:layout_alignParentTop Si la valeur est true, le bord supérieur de l’élément
Exemple 1
correspond au bord supérieur du parent (son
conteneur). Button
<?xmlversion="1.0" encoding="utf-8"?>
android:layout_alignParentBottom Si la valeur est true, correspondance des bords <RelativeLayout xmlns:android=
inférieurs. http://schemas.android.com/apk/res/android
xmlns:tools= http://schemas.android.com/tools
android:layout_alignParentLeft Si la valeur est true, correspondance des bords android:id="@+id/activ"
gauches. android:layout_width="match_parent"
android:layout_alignParentRight Si la valeur est true, correspondance des bords droits. android:layout_height="match_parent"
tools:context="com.td1.cour4.MainActivity">
android:layout_centerHorizontal Si la valeur est true, centrer l’enfant <Button android:text="Button"
horizontalement dans son conteneur. android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_centerInParent Si la valeur est true, centrer l’enfant android:id="@+id/button"
horizontalement et verticalement dans son android:layout_alignParentTop="true"
conteneur. android:layout_alignParentRight="true" />
</RelativeLayout>
android:layout_centerVertical Si la valeur est true, centrer l’enfant verticalement
dans son conteneur.
android:layout_alignParentEnd Si la valeur est true, le bord de fin de l’élément
correspond au bord de fin de son conteneur.
android:layout_alignParentStart Si la valeur est true, le bord de début de l’élément
correspond au bord de début de son conteneur.
 Exemple 2 Exemple 3
<Button <Button
android:id="@+id/button" android:id="@+id/button"
android:text="Button" android:text="Button"
android:layout_width="wrap_content" android:layout_width="wrap_content"
Button
android:layout_height="wrap_content" android:layout_height="wrap_content"
android:layout_centerInParent="true"/> android:layout_centerHorizontal="true"
android:layout_alignParentBottom="true"/>

Button

Positionnement 1 Positionnement 2
Attribut Description Attribut Description
android:layout_above="@id/e" Positionner l’élément au-dessus de android:layout_alignLeft="@+id/e" Le bord gauche de l’élément est
l‘élément référencé par son ID. aligné avec le bord gauche de
android:layout_below="@id/e" Positionner l’élément au-desous de l‘élément référencé par son ID.
l‘élément référencé par son ID. android:layout_alignRight="@+id/e" Le bord droit de l’élément est aligné
android:layout_toLeftOf="@id/e" Positionner l’élément à gauche de avec le bord droit de l‘élément
l‘élément référencé par son ID. référencé par son ID.
android:layout_alignBaseLine="@+id/e" Indique que les lignes de base des 2
android:layout_toRightOf="@id/e" Positionner l’élément à droite de
éléments sont alignées
l‘élément référencé par son ID.
android:layout_alignStart="@+id/e" le bord de début de l’élément
android:layout_alignTop="@id/e" Le bord supérieur de l’élément est
corresponde au bord de début de
aligné avec le bord supérieur de
l‘élément référencé par son ID.
l‘élément référencé par son ID.
android:layout_toEndOf ="@+id/e" le bord de fin de l’élément
android:layout_alignBottom="@id/e" Le bord inférieur de l’élément est corresponde au bord de fin de
aligné avec le bord inférieur de l‘élément référencé par son ID.
l‘élément référencé par son ID.
Exemple 1 Exemple 2
<Button
<Button android:id="@+id/Ok_butt" Exit android:id="@+id/Ok_butt" android:text="OK"
android:layout_width="wrap_content" Exit
android:text="OK"
android:layout_width="wrap_content" android:layout_height="wrap_content"
OK OK
android:layout_height="wrap_content" android:layout_alignParentLeft="true"
android:layout_alignParentLeft="true" android:layout_alignParentStart="true"
android:layout_alignParentStart="true" android:layout_margingTop=“20dp“
android:layout_margingTop=“20dp“ android:padding=“50dp"/>
android:padding=“50dp"/>
<Button android:id="@+id/Exit_butt" <Button android:id="@+id/Exit_butt"
android:text=“Exit" android:text=“Exit"
android:layout_width="wrap_content" android:layout_width="wrap_content"
android:layout_height="wrap_content“ android:layout_height="wrap_content“
android:layout_toRightOf="@+id/Ok_butt" /> android:layout_toRightOf="@+id/Ok_butt“
android:layout_alignTop="@+id/Ok_butt" />

Exemple 3 TableLayout
<Button Android TableLayout permet
android:id="@+id/Ok_butt" android:text="OK" d’organiser des groupes de vues en lignes
android:layout_width="wrap_content" et en colonnes.
android:layout_height="wrap_content"
android:layout_alignParentLeft="true"
OK L’attribut <TableRow> est utilisé pour
android:layout_alignParentStart="true"
Exit créer une ligne dans la table.
android:layout_margingTop=“20dp“
android:padding=“50dp"/>
Chaque ligne a zéro ou plusieurs cellules;
<Button chaque cellule peut contenir un objet
android:id="@+id/Exit_butt" View.
android:text=“Exit"
android:layout_width="wrap_content"
android:layout_height="wrap_content“
Les conteneurs TableLayout n'affichent
android:layout_toRightOf="@+id/Ok_butt“
pas de lignes de bordure pour leurs lignes,
android:layout_alignBottom="@+id/Ok_butt" />
colonnes ou cellules.

Nous pouvons également imbriquer un

autre TableLayout dans une cellule de
tableau.
 Attributs de TableLayout
<?xml version="1.0" encoding="utf-8"?>
<TableLayout xmlns:android="http://schemas.android.com/apk/res/android"
Attribut Description android:layout_width="match_parent"
android:layout_height="match_parent"
android:id C'est l'identifiant qui identifie de façon android:padding="6dp">
unique le layout <TableRow android:layout_height="wrap_content"
android:layout_width="match_parent">
android:collapseColumns Permet à la (aux) colonne (s) d'être réduite
ou de devenir invisible . Les index de <Button android:layout_width="match_parent"
colonne doivent être séparés par une android:layout_height="wrap_content"
virgule: 1, 3, 6. android:text=" Ligne 1 Colonne 1"
android:background="#b0b0b0"
android:shrinkColumns Permet de réduire la largeur de la colonne. android:padding="5dp"/>
Les index de colonne doivent être séparés
par une virgule: 1, 3, 6. <Button android:layout_width="match_parent"
android:layout_height="wrap_content"
Permet d’étendre la (les) colonne (s) pour android:text=" Ligne 1 Colonne 2"
android:stretchColumns android:background="#dcdcdc"
occuper l'espace libre disponible. Les index android:padding="5dp"/>
de colonne doivent être séparés par une </TableRow>
virgule: 1, 3, 6.

<TableRow
<TableRow android:layout_height="wrap_content"
android:layout_width="match_parent">
android:layout_height="wrap_content"
android:layout_width="match_parent"> <Button android:layout_width="match_parent"
android:layout_height="wrap_content" android:text="
Ligne 1 Colonne 1" android:background="#b0b0b0"
<Button android:layout_width="match_parent" android:padding="5dp"/>
android:layout_height="wrap_content" android:text="
<Button android:layout_width="match_parent"
Ligne 2 Colonne 1" android:background="#dcdcdc" android:layout_height="wrap_content" android:text="
android:padding="5dp"/> Ligne 1 Colonne 2" android:background="#dcdcdc"
android:padding="5dp"/>

</TableRow> </TableRow>

</TableLayout>
 Exemples
Widgets de base
Les widgets sont un aspect essentiel de la personnalisation de
l'écran d'accueil. Ils sont des objets des données et des
fonctionnalités les plus importantes d'une application, accessibles
directement à partir de l'écran d'accueil de l'utilisateur.

Les utilisateurs peuvent déplacer des widgets sur leurs panneaux

d'écran d'accueil et, s'ils sont pris en charge, les redimensionner
pour adapter la quantité d'informations dans un widget à leur
préférence.

Chaque type de widgets est une classe qui dérive de la classe "View".

Ils sont placé systématiquement dans des layouts.

o EditText o TextView
<EditText android:id="@+id/editText1“ <TextView android:id="@+id/TextView1“
android:layout_width="wrap_content“
android:layout_height="wrap_content" android:layout_width="wrap_content“
android:ems="10" android:hint="name" android:layout_height="wrap_content"
android:inputType="textPersonName" /> android:layout_centerHorizontal="true"
<EditText android:id="@+id/editText2"
android:text="Before Clicking"
android:layout_width="wrap_content" android:textColor="#f00"
android:layout_height="wrap_content" android:textSize="25sp"
android:ems="10" android:hint="password_0_9"
android:textStyle="bold|italic"
android:inputType="numberPassword" />
android:layout_marginTop="50dp" />

• L'attribut " android:textStyle " permet de choisir le style du texte, peut

• L'attribut "android:hint" permet d’afficher un commentaire prendre les valeurs “normal" , "bold" , "italic"
• L'attribut "android:inputType" permet de choisir un type d’entrée (text, mot • L'attribut "android:typeface " permet de choisir la police de caractères, peut
de passe, nombre, date, ….) prendre les valeurs "sans", "serif", "monospace"
• L'attribut "android:tex" permet d’initialiser le champ avec une valeur par défaut • L'attribut " android:textSize " permet de choisir la taille du texte
• La méthode getText() permet de récupérer le texte saisi • L'attribut " android:textColor " permet de choisir la couleure du texte
• La méthode setText() permet de placer un texte • ……
 Button/ImageButton oCheckBox
<CheckBox android:id="@+id/ChBox1"
android:layout_width=“wrap_content "
<Button android:id="@+id/But1 " android:layout_height="wrap_content"
android:layout_width="wrap_content " android:text= " Android"
android:textColor="#44f“
android:layout_height="wrap_content" Android
android:textStyle="bold|italic" />
android:gravity= " center"
android:text= " Android" /> <CheckBox android:id="@+id/ChBox2"
android:layout_width=“wrap_content "
<ImageButton android:id="@+id/ImgBut1 " android:layout_height="wrap_content"
android:layout_width="wrap_content " android:text= " Java"
android:layout_height="wrap_content" android:textColor="#f44“
android:gravity= " center" android:textStyle="bold|italic" />

android:srcCompat= " @mipmap/ic_launcher" /> • Pour vérifier si un CheckBox est coché:

CheckBox ch= (CheckBox) this.findViewById (R.id.ChBox1);

boolean b=ch.isChecked();

o o
RadioButton RadioGroup
<RadioButton android:id="@+id/RBut1 " <RadioGroup
android:layout_width=“match_parent " android:layout_width=“wrap_content "
android:layout_height="wrap_content"
android:layout_height="wrap_content" android:orientation= " vertical" >
android:text= " I am a radiobutton" />
RadioButton
android:layout_width=“wrap_content"
android:layout_height="wrap_content"
android:text= "OUI"
android:checked= “true" />

RadioButton
android:layout_width=“wrap_content"
android:layout_height="wrap_content"
• Pour vérifier si un RadioButtonest coché: android:text= “NON" />
RadioButton ch= (RadioButton) this.findViewById (R.id.RBut1);
</RadioGroup>
boolean b=ch.isChecked();
 o Toast Gérer l’ évènement de clic
 Andorid Toast peut être utilisé pour afficher
des informations à l’utilisateur pour une
courte période de temps. 1.Utiliser un click listener(l’interface
 Un toast contient un message à afficher
OnClickListener)
rapidement et disparaît après un certain
temps sans intervention de l’utilisateur. Package android.view.View.OnClickListener
 Vous pouvez également créer un toast
personnalisé, par exemple un toast affichant
une image. 2. Utiliser l’attribut
Un "toast" est une instance de la classe android:onClick dans un fichier xml
"Toast" (android.widget.Toast)

Toast toast= Toast.makeText(this,"Voici notre premier toast",

Toast.LENGTH_LONG);

toast.show();

1. Utiliser un click listener 2.Utiliser l’attribut android:onClickdans

public class
un fichier xml
MainActivity extends AppCompatActivity implements
OnClickListener
{
@Override
Protected void onCreate (Bundle savedInstanceState)
{ ……
……
Button b = (Button) this.findViewById(R.id.button);
b.setOnClickListener(this);}

public void onClick(Viewv)

{
//insérer votre code ici
}
}
[Ref] [Ref]