Lors de l'implémentation de Dialog sur Android, j'ai souvent utilisé la méthode d'implémentation de DialogFragment en tant que classe interne dans Activity, mais j'ai senti que le nombre d'étapes d'Activité serait important et qu'il serait difficile de savoir où se trouve Dialog. , J'ai pensé à une pratique pour unifier l'implémentation de Dialog.
Utilisez Factory pour afficher la boîte de dialogue au lieu d'implémenter la boîte de dialogue dans l'activité. Le spectacle de dialogue est également laissé à la classe commune au lieu de l'activité. Veuillez obtenir le code source de GitHub. https://github.com/ken-maki/k_commons.dialog
La configuration est la suivante.
com.android.k.commons.dialog ┣lib ┃┣BaseDialogFactory ┃┃ La classe BaseFactory de Dialog, une implémentation commune pour la génération de Dialog est écrite ici. ┃┣AlertDialogFactory ┃┃ La classe Factory parente pour l'implémentation d'AlertDialog, hérite de cette classe lors de la création d'un nouvel AlertDialog. ┃┣DialogGenerator ┃ ┃ Passez la classe qui gère l'affichage de la boîte de dialogue, Factory, et laissez-la Dialog. ┃┃ L'implémentation de la commande au moment de la génération du dialogue (par exemple, suppression de l'affichage en double) est écrite ici. ┃┗CommonAlertDialog ┃ Corps AlertDialog. Obtenez Builder de Factory pris comme argument et utilisez-le comme Builder de onCreateDialog. ┣mydialog ┃┣MySampleFooDialogFactory ┃┃DialogFactory pour l'exemple, modèle pour implémenter l'événement de clic de bouton dans Factory. ┃┗MySampleBarDialogFactory ┃DialogFactory pour exemple, modèle pour implémenter l'événement de clic de bouton avec un écouteur défini dans Factory. ┗MainActivity Exemple d'affichage de la boîte de dialogue Activité. Implémentez OnClickListener vous-même lors de l'affichage de MySampleBarDialogFactory.
AlertDialogFactory.java
abstract class BaseDialogFactory implements Serializable {
DialogInterface.OnCancelListener mOnCancelListener;
DialogInterface.OnDismissListener mOnDismissListener;
/**
* Activity to display Dialog.
*/
private Activity mActivity;
/**
* Constructor.
*
* @param activity create dialog for activity.
*/
BaseDialogFactory(Activity activity) {
if (activity == null) throw new IllegalArgumentException("activity is null.");
mActivity = activity;
}
/**
* get Activity.
*
* @return Activity
*/
protected Activity getActivity() {
return mActivity;
}
/**
* get Dialog Tag.
*
* @return Dialog Tag
*/
protected String getTag() {
return this.getClass().getSimpleName();
}
/**
* set OnCancelListener.
* @param listener action listener
*/
public void setOnCancelListener(DialogInterface.OnCancelListener listener) {
mOnCancelListener = listener;
}
/**
* set OnDismissListener.
* @param listener action listener
*/
public void setOnDismissListener(DialogInterface.OnDismissListener listener) {
mOnDismissListener = listener;
}
}
La classe parente de DialogFactory, qui implémente le traitement commun.
AlertDialogFactory.java
public abstract class AlertDialogFactory extends BaseDialogFactory {
protected DialogInterface.OnClickListener mPositiveClickListener;
protected DialogInterface.OnClickListener mNegativeClickListener;
/**
* Constructor.
*
* @param activity create dialog for activity.
*/
public AlertDialogFactory(Activity activity) {
super(activity);
}
/**
* create AlertDialog.Builder.
*
* @return can be Show AlertDialog.Builder
*/
public abstract AlertDialog.Builder build();
/**
* set OnClickListener for PositiveButton click.
* @param listener action listener
*/
public void setPositiveOnClickListener(DialogInterface.OnClickListener listener) {
mPositiveClickListener = listener;
}
/**
* set OnClickListener for NegativeButton click.
* @param listener action listener
*/
public void setNegativeClickListener(DialogInterface.OnClickListener listener) {
mNegativeClickListener = listener;
}
}
AlertDialog Classe d'usine. La méthode build () parente est le protagoniste de cette classe. La classe qui hérite d'AlertDialogFactory correspond aux informations que vous souhaitez afficher dans la méthode build (). Tout ce que vous avez à faire est de créer une implémentation qui crée et renvoie AlertDialog.Builder. Si vous souhaitez utiliser une boîte de dialogue autre que AlertDialog, c'est comme AlertDialogFactory Créez une usine parente. (SingleChoiceDialogFactory ou DatePickerDialogFactory)
CommonAlertDialog.java
public class CommonAlertDialog extends DialogFragment {
private static final String ARG_KEY_FACTORY = "f";
AlertDialogFactory mFactory;
public static CommonAlertDialog newInstance(AlertDialogFactory factory) {
Bundle bundle = new Bundle();
bundle.putSerializable(ARG_KEY_FACTORY, factory);
CommonAlertDialog dialog = new CommonAlertDialog();
dialog.setArguments(bundle);
return dialog;
}
@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
mFactory = (AlertDialogFactory)
getArguments().getSerializable(ARG_KEY_FACTORY);
if (mFactory == null) throw new IllegalArgumentException("factory is null.");
AlertDialog.Builder builder = mFactory.build();
if (builder == null) throw new IllegalStateException("AlertDialog.Builder is null.");
return builder.create();
}
@Override
public void onCancel(DialogInterface dialog) {
super.onCancel(dialog);
if (mFactory.mOnCancelListener != null) {
mFactory.mOnCancelListener.onCancel(dialog);
}
}
@Override
public void onDismiss(DialogInterface dialog) {
super.onDismiss(dialog);
if (mFactory.mOnDismissListener != null) {
mFactory.mOnDismissListener.onDismiss(dialog);
}
}
/**
* return AlertDialogFactory.
* @return AlertDialogFactory
*/
public AlertDialogFactory getFactory() {
return mFactory;
}
}
Corps de dialogue. Il y a à peu près deux choses que je fais. -Get Factory à partir de l'argument et le créer. -Exécute lorsque l'événement DialogInterface est défini.
MySampleFooDialogFactory.java
public class MySampleFooDialogFactory extends AlertDialogFactory {
public MySampleFooDialogFactory(Activity activity) {
super(activity);
}
@Override
public AlertDialog.Builder build() {
AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
builder.setTitle("Foo Dialog");
builder.setMessage("This Foo Dialog. please Button Click.");
builder.setPositiveButton("Ok", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
Toast.makeText(getActivity(), "Ok clicked.(listener setting from factory)", Toast.LENGTH_SHORT).show();
dialog.dismiss();
}
});
builder.setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
Toast.makeText(getActivity(), "Cancel clicked.(listener setting from factory)", Toast.LENGTH_SHORT).show();
dialog.dismiss();
}
});
builder.setCancelable(false);
return builder;
}
}
Héritez simplement AlertDialogFactory et implémentez build (). L'exemple est une implémentation simple, mais aussi pour les boîtes de dialogue complexes qui utilisent des dispositions personnalisées, etc. Le processus est implémenté dans build (). En faisant cela, lors de la création d'une boîte de dialogue, vous pouvez vous concentrer sur la création du contenu de la boîte de dialogue.
-Les implémenteurs de Dialog peuvent se concentrer uniquement sur l'implémentation du code qui génère AlertDialog.Builder. Le traitement commun est le générateur de dialogue, AlertDialogFactory, CommonAlertDialog En l'implémentant, tout le AlertDialog se comportera de manière unifiée. -Pas d'implémentation du dialogue et affichage du dialogue directement dans l'activité Comme il est faiblement couplé à Activity, il devrait être plus facile de le modifier du côté du dialogue par rapport à l'implémentation en classe interne.
C'était le premier article de Qiita, mais je me demande si un article comme celui-ci est correct. Je continuerai à publier des articles par essais et erreurs, alors j'espère que vous garderez un œil sur moi.
Code source https://github.com/ken-maki/k_commons.dialog