Comment afficher la boîte de dialogue d'alerte dans Android?

Créez l'objet boîte de dialogue d'alerte et configurez le générateur pour qu'il fasse référence au nouvel objet et crée la boîte.

Les AlertDialogs sont des fenêtres contextuelles utilisées pour demander à un utilisateur une action à entreprendre. Un AlertDialog peut également être utilisé pour d'autres actions telles que fournir une liste d'options parmi lesquelles choisir ou peut être personnalisé pour qu'un utilisateur fournisse des détails uniques tels que ses informations de connexion ou les paramètres de l'application.

Partie 1 sur 4: comprendre les boîtes de dialogue d'alerte

1
Comprendre la structure de base d'un dialogue d'alerte. Un AlertDialog est lorsque l'application Android utilise le système Android pour mettre en place des informations importantes pour un utilisateur à lire. Un AlertDialog peut également être utilisé pour avertir ou demander à l'utilisateur de modifier un paramètre important. Il contiendra trois composants de la boîte de dialogue.
- Un titre est facultatif mais peut être utile pour mettre un simple message ou une question. Cela peut également contenir une icône
- La zone de contenu qui peut afficher un message, une liste ou d'autres fonctions de mise en page personnalisées.
- Boutons d'action utilisés par l'utilisateur pour envoyer une réponse à la boîte de dialogue AlertDialog. Peut être un bouton positif, un bouton négatif ou un bouton neutre. Vous ne pouvez avoir qu'un seul de chaque type et jusqu'à trois boutons sur une boîte de dialogue d'alerte donnée.
2

Comprendre ce qu'est une classe. Une classe est un modèle qui vous permet de créer d'autres objets qui ont leurs propres propriétés et comportements. La classe AlertDialog est une sous-classe de la classe Dialog qui possède ses propres propriétés uniques de pouvoir afficher jusqu'à trois boutons en plus d'une invite Dialog standard.
3

Décidez de l'objectif de la boîte de dialogue d'alerte. A quoi sert la boîte de dialogue AlertDialog? Quelles seront les options pour l'utilisateur? Est-il possible que l'utilisateur ignore ce processus autrement? Notez ce que l'utilisateur sera invité à demander et notez ses choix et ce qu'il fait. Si l'écriture ne semble pas claire pour l'utilisateur, il se peut qu'il ne comprenne pas le but de la boîte de dialogue AlertDialog.
4

Rédigez et illustrez le dialogue d'alerte. Dessinez à quoi vous voulez que la boîte de dialogue AlertDialog ressemble. Notez dans la liste les options que vous souhaitez mettre en œuvre et les actions qui en résultent. Réfléchissez bien à ce que l'utilisateur est invité à demander et assurez-vous que l'écriture ne crée pas d'ambiguïté.
5

Téléchargez et installez le SDK Android. Un kit de développement logiciel ou SDK est utilisé pour développer des logiciels dans un environnement spécialisé pour la création de programmes et d'applications. Vous pouvez télécharger le SDK directement depuis le site Web du développeur Android.
6

Créer un nouveau projet. Même si vous avez un projet existant, la création d'un projet peut être idéale si vous souhaitez créer un environnement de test avant d'ajouter du code à votre projet principal. Dans la barre de menu, cliquez sur Fichier>Nouveau>Nouveau projet... et suivez les invites pour créer une nouvelle application.

Jusqu'à trois boutons sur une boîte de dialogue d'alerte donnée — Vous ne pouvez avoir qu'un seul de chaque type et jusqu'à trois boutons sur une boîte de dialogue d'alerte donnée.

Partie 2 sur 4: coder une invite de dialogue d'alerte

1
Créez un déclencheur pour la boîte de dialogue d'alerte. L'AlertDialog devra être affiché par une action effectuée par l'utilisateur. Vous pouvez modifier la mise en page principale de l'application sous le fichier "activity_main.xml" pour fournir un bouton avec lequel tester l'AlertDialog. Il existe deux façons de créer un bouton. Basculez entre les méthodes de conception et de codage en cliquant sur Conception ou Texte qui se trouvent au bas du volet de la fenêtre principale pour basculer entre les différents modes.
- Le SDK Android vous permet de modifier votre mise en page telle que le frontal principal qui se trouve dans la hiérarchie du projet sous le dossier Layout en utilisant une interface glisser-déposer pour créer un bouton.
- Vous pouvez également créer vous-même un bouton en code XML en éditant le document XML. Notez que la ligne indiquant l'action onClick est utilisée pour exécuter la boîte de dialogue AlertDialog lorsque le bouton est cliqué.
```
<Button android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Test Alert Dialog" android:id="@+id/buttonTest" android:layout_alignParentTop="true" android:layout_centerHorizontal="true" android:layout_marginTop="77dp" android:onClick="showDialog" /> 
```
2
Importez la classe alertdialog pour accéder à l'API. Cela sera nécessaire pour accéder à la classe pour créer l'invite AlertDialog. La classe AlertDialog offre la possibilité de créer la boîte de dialogue à l'écran, de définir ses options, d'afficher les titres et d'afficher le contenu dans la fenêtre de dialogue. Pour importer la classe, ouvrez le fichier "MainActivity.java". Faites défiler vers le haut du fichier et placez-le parmi les autres classes importées dans le projet.
```
importer android.app.AlertDialog; 
```
- Cette classe sera utile pour l'ensemble de votre application. Assurez-vous de l'ajouter au sommet de votre hiérarchie de code.
3
Identifiez un objet bouton. Un objet bouton permet d'identifier un widget bouton-poussoir tel qu'il apparaît dans le code XML. Dans votre code Java principal, "MainActivity.java" identifie et initialise un objet bouton au début de votre méthode principale, qui est la classe principale de votre application.
```
bouton privé buttonAlertDialog; buttonAlertDialog = (Bouton) findViewByID(R.id.buttonTest); 
```
4
Écoutez l'activité des boutons. À l'aide d'un OnClickListener, vous serez en mesure d'anticiper le moment où l'utilisateur appuie sur le bouton pour lancer une action. Un OnClickListener est effectué en écoutant les entrées de l'utilisateur lorsqu'il clique sur un bouton correspondant. Nous utiliserons l'écouteur pour ouvrir notre invite AlertDialog.
```
buttonAlertDialog.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View alertView) { }); 
```
5
Codez les composants de la boîte de dialogue d'alerte. Dans la fonction onClick, vous devrez créer un objet AlertDialog et lui fournir un titre, un message et des types de boutons à utiliser pour votre invite.
- Créez l'objet boîte de dialogue d'alerte et configurez le générateur pour qu'il fasse référence au nouvel objet et crée la boîte.
```
AlertDialog alertDialog1 = nouveau AlertDialog.Builder(MainActivity.this) 
```
6
Utilisez une fonction setter pour créer un titre. Une fonction setter vous permet de fournir une variable à un objet. C'est idéal pour éviter d'utiliser des variables globales qui peuvent causer des problèmes de performances. Un titre est entièrement facultatif, mais vous pouvez en définir un pour qu'il apparaisse en haut de la fenêtre AlertDialog.
```
alertDialog1.setTitle("exemple d'alerte de guide"); 
```
7
Utilisez une fonction de réglage pour définir un message. Entrez un message pour décrire ce que vous voulez que l'utilisateur réponde.
```
alertDialog1.setMessage("Android vous fournit un message pour accuser réception."); 
```
8
Utilisez les fonctions de réglage pour définir les propriétés des boutons. Fournissez des boutons à l'utilisateur. Vous pouvez utiliser une combinaison d'un bouton positif, d'un bouton négatif et d'un bouton neutre. Vous pouvez utiliser n'importe quelle combinaison des trois types, mais vous ne pouvez en utiliser qu'un pour trois boutons maximum. Utilisez les fonctions onClick pour fournir une action lorsque l'utilisateur clique sur l'un des trois boutons au bas de l'invite AlertDialog.
```
alertDialog1.setPositiveButton("OK", new OnClickListener() { public void onClick(DialogInterface dialog, int which){ } }).alertDialog1.setNegativeButton("OK", new OnClickListener() { public void onClick(DialogInterface dialog, int which){ } }).alertDialog1.setNeutralButton("OK", new OnClickListener() { public void onClick(DialogInterface dialog, int which){ } }); 
```
9
Utilisez une fonction de réglage pour activer le bouton d'annulation physique. Vous pouvez fournir une fonction d'annulation à la touche retour de l'appareil Android lui-même sans également appuyer sur l'un des boutons. S'il est défini sur false, le bouton de retour sur l'appareil Android est ignoré.
```
alertDialog1.setCancelable(true); 
```
10
Créez la boîte de dialogue. Utilisez-le pour créer l'objet AlertDialog. Cela devra être fait avant d'afficher l'AlertDialog à l'écran.
```
alertDialog1.create(); 
```
11
Afficher la boîte de dialogue. Une fois l'objet créé, utilisez cette action pour afficher l'AlertDialog à l'écran.
```
alertDialog1.show(); 
```

Importez la classe alertdialog pour accéder à l'API. Cela sera nécessaire pour accéder à la classe pour créer l'invite AlertDialog.

Partie 3 sur 4: coder une boîte de dialogue d'alerte de liste

1
Créez un tableau. Vous pouvez utiliser l'un des trois types de listes que vous pouvez utiliser. Au lieu d'utiliser la fonction setMessage, utilisez une liste si vous souhaitez fournir des réponses à choix multiples. Votre liste devra avoir un tableau créé indépendamment pour répertorier les différentes options disponibles. La liste utilisera un tableau pour afficher les différentes options disponibles.
```
éléments finaux CharSequence[] = {"Modifier", "Taux", "Partager", "Connexe"}; 
```
2
Créez une boîte de dialogue d'alerte de liste. Utilisez setItems pour fournir une liste d'options parmi lesquelles choisir. Cela apparaîtra sous la forme d'une liste de boutons radio à vérifier. La fonction nécessitera un tableau d'options parmi lesquelles choisir et un onClickListener pour représenter l'entrée de l'utilisateur.
```
dialog.setItems(items, new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialog, int item) { //Placer les actions résultantes dans cette fonction //La variable entière Item est la position d'index de l'élément sélectionné } }); 
```

3

Créez une liste à choix multiples. Utilisez setMultiChoiceItems si vous souhaitez que l'utilisateur puisse sélectionner plusieurs options. Leurs options seront affichées dans des cases à cocher lorsqu'elles sont utilisées.

dialog.setMultiChoiceItems(items, null, new DialogInterface.OnMultiChoiceClickListener() { public void onClick(DialogInterface dialog, int item, boolean isChecked) { if(isChecked) //S'il y a des éléments cochés //Item est la position d'index du Objet } });

4
Créez une liste qui n'autorise qu'un seul choix persistant. Utilisez setSingleChoiceItems si vous souhaitez que le choix singulier de l'utilisateur soit persistant. Leurs options apparaissent avec des boutons radio qui apparaissent sous forme de cercles avec des points à l'intérieur d'un choix sélectionné.
```
dialog.setSingleChoiceItems(items, -1, new DialogInterface.OnMultiChoiceClickListener() { public void onClick(DialogInterface dialog, int item) { if(isChecked) //S'il y a des éléments cochés //L'élément est la position d'index de l'élément sélectionné } }); 
```

Une nouvelle classe vous permettra de séparer le code de votre mise en page d'alerte unique.

Partie 4 sur 4: création d'une boîte de dialogue d'alerte personnalisée

1

Créez une mise en page personnalisée. Un AlertDialog personnalisé vous permet de créer une mise en page avec ses propres paramètres et peut obtenir des informations qui peuvent être utilisées pour obtenir les informations de connexion d'un utilisateur, les paramètres de configuration et plus encore. Vous pouvez créer une nouvelle mise en page qui sera créée au format de codage XML. Certains SDK Android offrent la possibilité d'utiliser une fonction glisser-déposer pour créer facilement une mise en page qui se convertira automatiquement en XML pour vous. Dans la barre de menu en haut de la fenêtre, cliquez sur Fichier>Nouveau>XML>Fichier XML de mise en page. Fournissez un nom de fichier de mise en page puis cliquez sur Terminer. Votre nouvelle mise en page apparaîtra dans le volet de la fenêtre principale.
2

Ajoutez des widgets ou d'autres composants à la mise en page. Vous pouvez ajouter des composants à l'aide de l'une des deux méthodes suivantes. Vous pouvez ouvrir le fichier de mise en page en regardant dans la hiérarchie du projet affichée sur le côté gauche. Ouvrez ensuite les chemins de dossiers suivants: "<AppName>>app>src>main>res>layout"
3

Créez une nouvelle classe Java. Une nouvelle classe vous permettra de séparer le code de votre mise en page d'alerte unique. Cliquez sur Fichier>Nouveau>Classe Java. Tapez un nom pour votre nouvelle classe Java puis cliquez sur OK. Pour cet exemple, nous appellerons cette classe d'exemple "CustomDialogExample".
4
Importez le fragment de boîte de dialogue. Le Fragment de Dialogue permet une compatibilité maximale avec les différentes versions du système d'exploitation Android.
```
importer android.support.v4.app.DialogFragment; 
```
- Assurez-vous que la méthode de classe principale s'étend jusqu'au DialogFragment.
```
la classe publique CustomDialogExample étend DialogFragment 
```
5
Créez un objet de gonflage de mise en page et un objet de vue. Un gonfleur de mise en page instancie un fichier XML de mise en page dans des objets de vue. Un objet View est la structure de base des composants de l'interface utilisateur dans un espace d'écran rectangulaire et dessine des objets et des widgets à l'écran.
```
DispositionInflater gonfleur; Afficher la vue personnalisée; 
```
6
Créez la disposition de boîte de dialogue personnalisée. Nous aurons besoin qu'il soit public pour qu'il soit accessible ailleurs dans l'application et qu'il renvoie un objet Dialog. Il prendra un objet Bundle.
```
Public Dialog onCreateDialog(Bundle saveInstanceState){ } 
```
7
Gonflez la mise en page à partir de la mise en page XML personnalisée. Une fois les objets LayoutInflater et View créés, gonflez la mise en page et obtenez la mise en page personnalisée sur l'objet View à partir de la fonction onCreateDialog.
```
gonfler = getActivity().getLayoutInflater(); customView = gonfler.gonfler(R.layout.dialog_custom_background, null); 
```
8
Créez la boîte de dialogue d'alerte personnalisée. Dans la fonction onCreateDialog, utilisez le générateur AlertDialog pour créer la mise en page.
```
Générateur AlertDialog.Builder = new AlertDialog.Builder(getActivity());}} 
```
- Vous souhaiterez peut-être ajouter un bouton pour fermer l'AlertDialog.
```
builder.setView(customView).setPositiveButton("OK", new OnClickListener() { public void onClick(DialogInterface dialog, int which){} }); 
```
9
Renvoie la boîte de dialogue d'alerte personnalisée. Parce que nous ne sommes pas au centre de l'application, nous terminerons la fonction onCreateDialog en revenant avec notre nouveau AlertDialog.
```
return builder.create(); 
```
10
Appelez la boîte de dialogue d'alerte personnalisée à partir de la méthode principale. Vous devrez faire appel à votre fonction depuis un autre endroit, comme la méthode principale de votre application. Pour cet exemple, nous appellerons cette fonction publique customAlertDialogExample qui prendra en compte un objet View.
```
public void customAlertDialogExample(View customView) { CustomDialogExample dialog = new CustomDialogExample(); dialog.show(getSupportFragmentManager(), "MyCustomAlertDialog"); } 
```

Conseils

Le SDK notera si quelque chose ne peut pas être invoqué, indiqué par un texte rouge. En cliquant sur le texte, le SDK vous invitera à importer la bibliothèque correspondante à ajouter à votre projet. Maintenez Alt+ ↵ Enterpour ajouter la bibliothèque à votre projet.

Lisez aussi: Comment rooter un droïde Motorola?