Vues, widgets et styles

Dans ce chapitre, nous aborderons les sujets suivants:
► Insérer un widget dans une mise en page
► Utilisation de graphiques pour montrer l'état du bouton
► Création d'un widget lors de l'exécution
► Création d'un composant personnalisé
► Appliquer un style à une vue
► Transformer un style en thème
► Sélection d'un thème basé sur la version du système d'exploitation Android
introduction
Le terme widgets peut faire référence à plusieurs concepts différents dans Android. Lorsque la plupart des gens parlent de widgets, ils font référence à des widgets d'applications, qui sont généralement visibles sur l'écran d'accueil. Les widgets d'applications sont comme des mini-applications en elles-mêmes car elles fournissent généralement un sous-ensemble de fonctionnalités, en fonction de leur application principale. (Habituellement, la plupart des widgets d'application sont installés avec une application, mais ce n'est pas une exigence.Ils peuvent être des applications autonomes dans un format de widget.) Un exemple commun de widget d'application est une application météo qui offre plusieurs widgets d'application différents pour l'écran d'accueil . Le chapitre 5, Explorer les fragments, AppWidgets et l'interface utilisateur du système, traite des widgets d'application de l'écran d'accueil et fournit des recettes pour créer les vôtres.
Lors du développement pour Android, le terme widgets fait généralement référence à des vues spécialisées placées dans les fichiers de disposition, tels que Button, TextView, CheckBox, etc. Dans ce chapitre, nous allons nous concentrer sur les widgets pour le développement d'applications.
Pour afficher la liste des widgets fournis dans le SDK Android, ouvrez un fichier de présentation dans Android Studio et cliquez sur l'onglet Conception. Sur le côté gauche de la vue Conception, vous verrez la section Widget sous la section Mise en page, comme dans la capture d'écran suivante:
Comme vous pouvez le voir dans la liste, le SDK Android fournit de nombreux widgets utiles, depuis un simple TextView, Button ou Checkbox jusqu'aux widgets beaucoup plus complexes tels que Clock, DatePicker et Calendar. Aussi utiles que soient les widgets intégrés, il est également très facile de développer ce qui est fourni dans le SDK. Nous pouvons étendre un widget existant pour personnaliser ses fonctionnalités, ou nous pouvons créer notre propre widget à partir de zéro en étendant la classe Vue de base. (Nous en donnerons un exemple dans la recette Création d'un composant personnalisé plus tard.)
L'aspect visuel des widgets peut également être personnalisé. Ces paramètres peuvent être utilisés pour créer des styles, qui à leur tour peuvent être utilisés pour créer des thèmes. Tout comme avec d'autres environnements de développement, la création d'un thème offre l'avantage de changer facilement l'apparence de l'ensemble de notre application avec un minimum d'effort. Enfin, le SDK Android propose également de nombreux thèmes et variantes intégrés, tels que le thème Holo d'Android 3/4 et le thème Material d'Android 5. (Android 6.0 n'a pas publié de nouveau thème.)

Détails
Catégorie : Vues, widgets et styles
Affichages : 19
Comme nous l'avons vu dans les recettes précédentes, le SDK Android fournit un large éventail de composants. Mais que se passe-t-il lorsque vous ne trouvez pas un composant prédéfini qui correspond à vos besoins uniques? Vous pouvez toujours créer le vôtre!
Dans cette recette, nous allons créer un composant personnalisé dérivé de la classe View, tout comme les widgets intégrés. Voici un aperçu de haut niveau:
1. Créez une nouvelle classe qui étend View.
2. Créez un ou plusieurs constructeurs personnalisés.
3. Remplacez onMeasure () et l'implémentation par défaut renvoie une taille de 100 x 100.
4. Remplacez onDraw () et l'implémentation par défaut ne dessine rien.
5. Définissez des méthodes et des écouteurs personnalisés (par exemple, sur <Event> ()).
6. Implémenter des fonctionnalités personnalisées.
Tout en surchargeant onMeasure () et onDraw () n'est pas strictement requis, le comportement par défaut n'est probablement pas ce que vous voulez.

Se préparer
Commencez un nouveau projet dans Android Studio et appelez-le CustomView. Utilisez les options de l'assistant par défaut, y compris le SDK téléphone et tablette, et sélectionnez Activité vide lorsque vous êtes invité à entrer le type d'activité. Une fois les fichiers de projet créés et ouverts dans Android Studio, vous êtes prêt à commencer.

Comment faire...
Nous allons créer une nouvelle classe pour que notre composant personnalisé dérive de la classe Android View. Notre composant personnalisé peut être une sous-classe d'une classe existante, telle que l'activité, mais nous allons le créer dans un fichier séparé pour le rendre plus facile à gérer. Voici les étapes:
1. Commencez par créer une nouvelle classe Java et appelez-la également CustomView. C'est ici que nous implémenterons notre composant personnalisé, comme décrit dans l'introduction.
2. Modifiez le constructeur de classe afin qu'il étend View. Cela devrait ressembler à ceci:
la classe publique CustomView étend View {
3. Définissez un objet Paint pour la classe, qui sera utilisé dans onDraw ():
Paint final mPaint = new Paint ();
4. Créez un constructeur par défaut, qui nécessite l'activité Contexte, afin que nous puissions gonfler la vue. Nous allons également définir les propriétés de la peinture ici. Le constructeur devrait ressembler à ceci:
public CustomView (Context context) {super (contexte); mPaint.setColor (Color.BLACK); mPaint.setTextSize (30);
}
5. Remplacez la méthode onDraw () comme suit:
@Passer outre
void protégé onDraw (Canvas canvas) {super.onDraw (canvas); setBackgroundColor (Color.CYAN);
canvas.drawText ("Texte personnalisé", 100, 100, mPaint); invalider();
}
6. Enfin, gonflez notre vue personnalisée dans MainActivity.java en remplaçant setContentView () par notre vue, comme indiqué:
setContentView (nouveau CustomView (this));
7. Exécutez l'application sur un périphérique ou un émulateur pour le voir en action.

Comment ça marche...
Nous commençons par étendre la classe View, tout comme les composants intégrés. Ensuite, nous créons le constructeur par défaut. Ceci est important car nous avons besoin du contexte pour passer à la super classe, ce que nous faisons avec l'appel:
super (contexte);
Nous devons surcharger onDraw (), sinon, comme mentionné dans l'introduction, notre vue personnalisée n'affichera rien. Lorsque onDraw () est appelé, le système transmet un objet Canvas. La toile est la zone de l'écran pour notre vue. (Puisque nous n'avons pas surchargé onMeasure (), notre vue serait 100 x 100, mais puisque notre activité entière consiste seulement en cette vue, nous obtenons l'intégralité de l'écran comme toile.)
Nous avons créé l'objet Paint au niveau de la classe, et en dernier, pour être plus efficace avec l'allocation de mémoire. (onDraw () devrait être aussi efficace que possible puisqu'il peut être appelé plusieurs fois par seconde.) Comme vous le voyez depuis l'exécution du programme, notre implémentation onDraw () définit simplement la couleur d'arrière-plan sur cyan et imprime le texte à l'écran. ()).
Il y a plus...
En fait, il y en a beaucoup plus. Nous venons de toucher la surface de ce que vous pouvez faire avec un composant personnalisé. Heureusement, comme vous le voyez dans cet exemple, il ne faut pas beaucoup de code pour obtenir les fonctionnalités de base. Nous pourrions facilement passer un chapitre entier sur des sujets tels que passer des paramètres de disposition à la vue, ajouter des rappels d'écouteurs, surcharger onMeasure (), utiliser notre vue dans l'EDI, et ainsi de suite. Ce sont toutes les fonctionnalités que vous pouvez ajouter selon vos besoins.
Alors qu'un composant personnalisé doit être capable de gérer n'importe quelle solution, d'autres options peuvent nécessiter moins de codage. L'extension d'un widget existant est souvent suffisante sans la surcharge d'un composant personnalisé. Si ce dont vous avez besoin est une solution avec plusieurs widgets, il y a aussi le contrôle composé. Un contrôle composé, comme une zone de liste déroulante, est juste deux ou plusieurs contrôles regroupés en un seul widget.
Un contrôle composé s'étend généralement à partir d'une mise en page et non d'une vue, puisque vous allez ajouter plusieurs widgets. Vous n'auriez probablement pas besoin de surcharger onDraw () et onMeasure (), car chaque widget gérerait le dessin dans leurs méthodes respectives.
Voir également
► Pour plus d'informations sur le dessin, consultez le chapitre 9, Graphisme et animation.
Pour plus de détails sur l'objet View, reportez-vous à la ressource Développeur Android à l'adresse:
http://developer.android.com/reference/android/view/View.html
 

Détails
Catégorie : Vues, widgets et styles
Affichages : 15
Comme mentionné précédemment, généralement, l'interface utilisateur est déclarée dans des fichiers XML, puis modifiée au cours de l'exécution via le code Java. Il est possible de créer complètement l'interface utilisateur en code Java, mais pour une mise en page complexe, elle ne sera généralement pas considérée comme la meilleure pratique.
L'exemple GridView du chapitre précédent a été créé dans le code. Mais contrairement à la recette GridView, dans cette recette, nous allons ajouter une vue à la disposition existante définie dans
activity_main.xml.
Se préparer
Créez un nouveau projet dans Android Studio et appelez-le RuntimeWidget. Sélectionnez l'option Empty Activity lorsque vous êtes invité à entrer le type d'activité.

Comment faire...
Nous allons commencer par ajouter un attribut ID à la mise en page existante afin que nous puissions accéder à la mise en page dans le code. Une fois que nous avons une référence à la mise en page dans le code, nous pouvons ajouter de nouvelles vues à la mise en page existante. Voici les étapes:
1. Ouvrez le fichier res / layout / activity_main.xml et ajoutez un attribut ID au fichier principal.
RelativeLayout, comme suit:
android: id = "@ + id / layout"
2. Supprimez complètement l'élément <TextView> par défaut.
3. Ouvrez le fichier MainActivity.java pour pouvoir ajouter du code à la méthode onCreate (). Ajoutez le code suivant (après setContentView ()) pour obtenir une référence
à la RelativeLayout:
RelativeLayout layout = (RelativeLayout) findViewById (R.id.layout);
4. Créez un DatePicker et ajoutez-le à la mise en page avec le code suivant:
DatePicker DatePicker = new DatePicker (this); layout.addView (datePicker);
5. Exécutez le programme sur un périphérique ou un émulateur.

Comment ça marche...
C'est un code très simple. Tout d'abord, nous obtenons une référence à la structure parent en utilisant findViewById. Nous avons ajouté l'ID au RelativeLayout existant (à l'étape 1) pour le rendre plus facile à référencer. Nous créons un DatePicker dans le code et l'ajoutons à la mise en page avec la méthode addView ().

Il y a plus...
Et si nous voulions créer toute la mise en page à partir du code? Bien que cela ne soit pas considéré comme la meilleure pratique, il est parfois plus facile (et moins complexe) de créer une mise en page à partir du code. Voyons à quoi ressemblera cet exemple si nous n'avons pas utilisé la disposition de activity_main.xml. Voici comment onCreate () ressemblerait:
@Passer outre
void protégé onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState);
RelativeLayout layout = nouveau RelativeLayout (this);
DatePicker DatePicker = new DatePicker (this);
layout.addView (datePicker);
setContentView (disposition);
}
Dans cet exemple, ce n'est vraiment pas si différent. Si vous créez une vue dans le code et souhaitez la référencer plus tard, vous devez conserver une référence à l'objet ou attribuer un ID à l'affichage pour utiliser findViewByID (). Pour donner un ID à une vue, utilisez la méthode setID () en passant dans View. generateViewId () (pour générer un identifiant unique) ou définissez l'identifiant en utilisant <resources> dans xml.

Détails
Catégorie : Vues, widgets et styles
Affichages : 16
Nous avons parlé de la polyvalence d'Android Views et de la façon dont le comportement et l'apparence visuelle peuvent être personnalisés. Dans cette recette, nous allons créer un sélecteur d'état drawable, qui est une ressource définie dans XML qui spécifie le drawable à utiliser en fonction de l'état de la vue.
Les états les plus couramment utilisés, avec les valeurs possibles, comprennent:
Pour définir un sélecteur d'état, créez un fichier XML avec l'élément <selector>, comme indiqué:
<? xml version = "1.0" encoding = "utf-8"?>
http://schemas.android.com/apk/res/android" > </selector> "><sélecteur xmlns: android = "http://schemas.android.com/apk/res/android"> </ selector>
Dans l'élément <selector>, nous définissons un <item> pour identifier le retraitable à utiliser en fonction du ou des états spécifiés. Voici un exemple d'élément <item> utilisant plusieurs états:
<item
android: drawable = "@ android: couleur / darker_gray"
android: state_checked = "vrai"
android: state_selected = "faux" />
Il est important de se rappeler que le fichier est lu de haut en bas de sorte que le premier élément qui répond aux exigences de l'état sera utilisé. Un drawable par défaut, un sans états inclus, devrait aller en dernier.
Pour cette recette, nous allons utiliser un sélecteur d'état pour changer la couleur de fond en fonction de la
ToggleButton état.

Se préparer
Créez un nouveau projet dans Android Studio et appelez-le StateSelector en utilisant les options par défaut Phone & Tablet. Lorsque vous êtes invité à entrer le type d'activité, sélectionnez Activité vide. Pour faciliter la saisie du code de cette recette, nous utiliserons une couleur comme graphique pour représenter l'état du bouton.

Comment faire...
Nous allons commencer par créer le sélecteur d'état, qui est un fichier de ressources défini avec du code XML. Nous allons ensuite configurer le bouton pour utiliser notre nouveau sélecteur d'état. Voici les étapes:
1. Créez un nouveau fichier XML dans le dossier res / drawable et appelez-le: state_selector. xml. Le fichier doit être constitué du code XML suivant:
<? xml version = "1.0" encoding = "utf-8"?>
http://schemas.android.com/apk/res/ android"> "><sélecteur xmlns: android = "http://schemas.android.com/apk/res/ android">
<item
android: drawable = "@ android: couleur / darker_gray"
android: state_checked = "vrai" />
<item
android: drawable = "@ android: couleur / blanc"
android: state_checked = "faux" />
</ selector>
2. Maintenant, ouvrez le fichier activity_main.xml et placez un ToggleButton comme suit:
<ToggleButton
android: layout_width = "wrap_content"
android: layout_height = "wrap_content"
android: text = "Nouveau ToggleButton"
android: id = "@ + id / toggleButton"
android: layout_centerVertical = "vrai"
android: layout_centerHorizontal = "vrai"
android: background = "@ drawable / state_selector" />
3. Exécutez l'application sur un périphérique ou un émulateur.
dm-

 
Comment ça marche...
Le concept principal à comprendre ici est le sélecteur d'état Android. Comme indiqué à l'étape 2, nous avons créé un fichier de ressources qui spécifiait un drawable (une couleur dans ce cas) basé sur
state_checked.
Android prend en charge de nombreuses autres conditions d'état en plus cochée. En tapant android: state, regardez la liste déroulante autocomplete pour voir la liste des autres options.
Une fois que la ressource dessinable est créée (le XML de l'étape 1), il suffit de dire à la vue de l'utiliser. Puisque nous voulions que la couleur de fond change en fonction de l'état, nous utilisons
l'androïde: propriété d'arrière-plan.
state_selector.xml est une ressource pouvant être dessinée qui peut être transmise à n'importe quelle propriété qui accepte un drawable. Nous pourrions, par exemple, remplacer le bouton dans une case à cocher avec le code XML suivant:
android: button = "@ drawable / state_selector"
Il y a plus...
Et si nous voulions des images réelles pour les graphiques au lieu d'un simple changement de couleur? C'est aussi simple que de changer le drawable référencé dans l'état de l'objet.
https://pixabay.com/ (this was chosen because the images are free to use and didn't require a login.) ">Le code source disponible pour le téléchargement utilise deux images graphiques, téléchargées depuis: https://pixabay.com/ (ceci a été choisi parce que les images sont libres d'utilisation et ne nécessitaient pas de connexion.)
Une fois que vous avez vos images désirées, placez-les dans le dossier res / drawable. Ensuite, modifiez la ligne d'élément d'état dans le fichier XML pour référencer vos images. Voici un exemple:
<item
android: drawable = "@ drawable / checked_on"
android: state_checked = "vrai" />
(Modifiez check_on pour qu'il corresponde au nom de votre ressource d'image.)
Utilisation de dossiers désignés pour les ressources spécifiques à l'écran
Lorsque Android rencontre une référence @drawable, il s'attend à trouver la cible dans l'un des dossiers res / drawable. Ils sont conçus pour différentes densités d'écran: ldpi (points bas par pouce), mdpi (moyen), hdpi (haut) et xhdpi (extra-haut) et ils nous permettent de créer des ressources pour des périphériques cibles spécifiques. Lorsqu'une application est en cours d'exécution sur un périphérique spécifique, Android chargera les ressources à partir du dossier désigné qui correspond le mieux à la densité réelle de l'écran.
S'il trouve ce dossier vide, il essayera la correspondance la plus proche et ainsi de suite jusqu'à ce qu'il trouve la ressource nommée. À des fins de tutoriel, un ensemble distinct de fichiers pour chaque densité possible n'est pas nécessaire, et donc placer nos images dans le dossier drawable est un moyen simple d'exécuter l'exercice sur n'importe quel appareil.

Voir également
Pour un autre exemple sur la sélection des ressources Android, voir la recette sur Sélectionner un thème basé sur la version du système d'exploitation plus tard.

Détails
Catégorie : Vues, widgets et styles
Affichages : 14
Nous avons parlé de la polyvalence d'Android Views et de la façon dont le comportement et l'apparence visuelle peuvent être personnalisés. Dans cette recette, nous allons créer un sélecteur d'état drawable, qui est une ressource définie dans XML qui spécifie le drawable à utiliser en fonction de l'état de la vue.
Les états les plus couramment utilisés, avec les valeurs possibles, comprennent:
Pour définir un sélecteur d'état, créez un fichier XML avec l'élément <selector>, comme indiqué:
<? xml version = "1.0" encoding = "utf-8"?>
http://schemas.android.com/apk/res/android" > </selector> "><sélecteur xmlns: android = "http://schemas.android.com/apk/res/android"> </ selector>
Dans l'élément <selector>, nous définissons un <item> pour identifier le retraitable à utiliser en fonction du ou des états spécifiés. Voici un exemple d'élément <item> utilisant plusieurs états:
<item
android: drawable = "@ android: couleur / darker_gray"
android: state_checked = "vrai"
android: state_selected = "faux" />
Il est important de se rappeler que le fichier est lu de haut en bas de sorte que le premier élément qui répond aux exigences de l'état sera utilisé. Un drawable par défaut, un sans états inclus, devrait aller en dernier.
Pour cette recette, nous allons utiliser un sélecteur d'état pour changer la couleur de fond en fonction de la
ToggleButton état.

Se préparer
Créez un nouveau projet dans Android Studio et appelez-le StateSelector en utilisant les options par défaut Phone & Tablet. Lorsque vous êtes invité à entrer le type d'activité, sélectionnez Activité vide. Pour faciliter la saisie du code de cette recette, nous utiliserons une couleur comme graphique pour représenter l'état du bouton.

Comment faire...
Nous allons commencer par créer le sélecteur d'état, qui est un fichier de ressources défini avec du code XML. Nous allons ensuite configurer le bouton pour utiliser notre nouveau sélecteur d'état. Voici les étapes:
1. Créez un nouveau fichier XML dans le dossier res / drawable et appelez-le: state_selector. xml. Le fichier doit être constitué du code XML suivant:
<? xml version = "1.0" encoding = "utf-8"?>
http://schemas.android.com/apk/res/ android"> "><sélecteur xmlns: android = "http://schemas.android.com/apk/res/ android">
<item
android: drawable = "@ android: couleur / darker_gray"
android: state_checked = "vrai" />
<item
android: drawable = "@ android: couleur / blanc"
android: state_checked = "faux" />
</ selector>
2. Maintenant, ouvrez le fichier activity_main.xml et placez un ToggleButton comme suit:
<ToggleButton
android: layout_width = "wrap_content"
android: layout_height = "wrap_content"
android: text = "Nouveau ToggleButton"
android: id = "@ + id / toggleButton"
android: layout_centerVertical = "vrai"
android: layout_centerHorizontal = "vrai"
android: background = "@ drawable / state_selector" />
3. Exécutez l'application sur un périphérique ou un émulateur.
dm-

 
Comment ça marche...
Le concept principal à comprendre ici est le sélecteur d'état Android. Comme indiqué à l'étape 2, nous avons créé un fichier de ressources qui spécifiait un drawable (une couleur dans ce cas) basé sur
state_checked.
Android prend en charge de nombreuses autres conditions d'état en plus cochée. En tapant android: state, regardez la liste déroulante autocomplete pour voir la liste des autres options.
Une fois que la ressource dessinable est créée (le XML de l'étape 1), il suffit de dire à la vue de l'utiliser. Puisque nous voulions que la couleur de fond change en fonction de l'état, nous utilisons
l'androïde: propriété d'arrière-plan.
state_selector.xml est une ressource pouvant être dessinée qui peut être transmise à n'importe quelle propriété qui accepte un drawable. Nous pourrions, par exemple, remplacer le bouton dans une case à cocher avec le code XML suivant:
android: button = "@ drawable / state_selector"
Il y a plus...
Et si nous voulions des images réelles pour les graphiques au lieu d'un simple changement de couleur? C'est aussi simple que de changer le drawable référencé dans l'état de l'objet.
https://pixabay.com/ (this was chosen because the images are free to use and didn't require a login.) ">Le code source disponible pour le téléchargement utilise deux images graphiques, téléchargées depuis: https://pixabay.com/ (ceci a été choisi parce que les images sont libres d'utilisation et ne nécessitaient pas de connexion.)
Une fois que vous avez vos images désirées, placez-les dans le dossier res / drawable. Ensuite, modifiez la ligne d'élément d'état dans le fichier XML pour référencer vos images. Voici un exemple:
<item
android: drawable = "@ drawable / checked_on"
android: state_checked = "vrai" />
(Modifiez check_on pour qu'il corresponde au nom de votre ressource d'image.)
Utilisation de dossiers désignés pour les ressources spécifiques à l'écran
Lorsque Android rencontre une référence @drawable, il s'attend à trouver la cible dans l'un des dossiers res / drawable. Ils sont conçus pour différentes densités d'écran: ldpi (points bas par pouce), mdpi (moyen), hdpi (haut) et xhdpi (extra-haut) et ils nous permettent de créer des ressources pour des périphériques cibles spécifiques. Lorsqu'une application est en cours d'exécution sur un périphérique spécifique, Android chargera les ressources à partir du dossier désigné qui correspond le mieux à la densité réelle de l'écran.
S'il trouve ce dossier vide, il essayera la correspondance la plus proche et ainsi de suite jusqu'à ce qu'il trouve la ressource nommée. À des fins de tutoriel, un ensemble distinct de fichiers pour chaque densité possible n'est pas nécessaire, et donc placer nos images dans le dossier drawable est un moyen simple d'exécuter l'exercice sur n'importe quel appareil.

Voir également
Pour un autre exemple sur la sélection des ressources Android, voir la recette sur Sélectionner un thème basé sur la version du système d'exploitation plus tard.

Détails
Catégorie : Vues, widgets et styles
Affichages : 13

Comme vous avez pu le voir dans les recettes précédentes, les widgets sont déclarés dans un fichier de mise en page ou créés dans du code. Pour cette recette, nous allons étape par étape pour ajouter un bouton avec Android Studio Designer. (Pour les recettes ultérieures, nous allons simplement afficher la présentation XML à partir de TextView.) Après avoir créé le bouton, nous allons créer un onClickListener ().


Se préparer
Commencez un nouveau projet dans Android Studio et appelez-le Insertwidget. Utilisez les options par défaut pour créer un projet Téléphone et tablette et sélectionnez Activité vide lorsque vous êtes invité à entrer le type d'activité. Vous pouvez supprimer le TextView par défaut (ou le laisser) car il ne sera pas nécessaire pour cette recette.


Comment faire...
Pour insérer un widget dans une mise en page, procédez comme suit:
1. Ouvrez le fichier activity_main.xml dans Android Studio et cliquez sur l'onglet Conception.
 

t49]
2. Trouvez le bouton dans la liste des widgets et faites-le glisser au centre de l'écran d'activité sur la droite. Android définira automatiquement les paramètres de disposition en fonction de l'endroit où le bouton est déposé. Si vous centrez le bouton comme indiqué dans la capture d'écran, Android Studio définit ces paramètres dans le fichier XML.
 

3. Pour voir le fichier XML créé, cliquez sur l'onglet Texte comme indiqué dans la capture d'écran suivante. Voyez comment le bouton est centré en utilisant les paramètres RelativeLayout. Prenez également note de l'identifiant par défaut car nous en aurons besoin pour l'étape suivante.
-d0}
 
4. Maintenant, ouvrez le fichier MainActivity.java pour modifier le code. Ajouter le code suivant
à la méthode onCreate () pour configurer onClickListener ():
Bouton bouton = (Bouton) findViewByld (R.id.button); button.setOnClickListener (new View.OnClickListener () {
@Passer outre
public void onClick (Voir la vue) {
Toast.makeText (MainActivity.this, "Cliqué",
Toast.LENGTH_SHORT) .show ();

}
});
5. Exécutez l'application sur un périphérique ou un émulateur.
Comment ça marche...
La création de l'interface utilisateur avec Android Studio est aussi simple que de faire glisser et de déposer des vues. Vous pouvez également modifier les propriétés des vues directement dans l'onglet Conception. Passer au code XML est aussi simple que de cliquer sur l'onglet Texte.
Ce que nous avons fait ici est très commun dans le développement d'Android: créer l'interface utilisateur en XML, puis raccorder les composants de l'interface utilisateur (Views) dans le code Java. Pour référencer une vue à partir d'un code, un identifiant de ressource doit lui être associé. Ceci est fait en utilisant le paramètre id:
android: id = "@ + id / bouton"
Notre fonction onClickListener affiche un message pop-up sur l'écran appelé Toast, lorsque le bouton est enfoncé.

{Kb
Il y a plus...
Jetez un coup d'oeil au format de l'identifiant que nous avons précédemment créé, @ + id / button. Le @ spécifie que cela va être une ressource et le signe + indique une nouvelle ressource. (Si nous omettons d'inclure le signe plus, nous obtiendrons une erreur de compilation indiquant qu'aucune ressource ne correspond au nom indiqué).
Voir également
► Butter Knife (Projet Open Source) -Field et méthode de liaison pour Android Views:
http://jakewharton.github.io/butterknife/