Bei der Implementierung von Dialog unter Android habe ich häufig die Methode zur Implementierung von DialogFragment als innere Klasse in Aktivität verwendet. Ich hatte jedoch das Gefühl, dass die Anzahl der Aktivitätsschritte groß und es schwierig ist zu wissen, wo sich Dialog befindet. Ich dachte an eine Praxis, um die Umsetzung des Dialogs zu vereinheitlichen.
Verwenden Sie Factory, um Dialog anzuzeigen, anstatt Dialog in Aktivität zu implementieren. Die Dialogshow bleibt anstelle der Aktivität auch der gemeinsamen Klasse überlassen. Bitte beziehen Sie den Quellcode von GitHub. https://github.com/ken-maki/k_commons.dialog
Die Konfiguration ist wie folgt.
com.android.k.commons.dialog ┣lib ┃┣BaseDialogFactory ┃┃ Die BaseFactory-Klasse von Dialog, eine allgemeine Implementierung für die Dialoggenerierung, wird hier geschrieben. ┃┣AlertDialogFactory ┃┃ Die übergeordnete Factory-Klasse zum Implementieren von AlertDialog erbt diese Klasse beim Erstellen eines neuen AlertDialogs. ┃┣DialogGenerator ┃ ┃ Übergeben Sie die Klasse für die Dialoganzeige Factory und lassen Sie sie Dialog. ┃┃ Hier wird die Implementierung der Steuerung zum Zeitpunkt der Dialoggenerierung (z. B. Unterdrückung der doppelten Anzeige) beschrieben. ┃┗CommonAlertDialog ┃ AlertDialog-Body. Holen Sie sich Builder aus Factory als Argument und verwenden Sie es als Builder von onCreateDialog. ┣mydialog ┃┣MySampleFooDialogFactory ┃┃DialogFactory für Beispiel, Muster zum Implementieren des Schaltflächenklickereignisses in Factory. ┃┗MySampleBarDialogFactory ┃DialogFactory für Beispiel, Muster zum Implementieren eines Schaltflächenklickereignisses mit in Factory festgelegtem Listener. ┗MainActivity Beispielaktivität für die Dialoganzeige. Implementieren Sie OnClickListener selbst, wenn Sie MySampleBarDialogFactory anzeigen.
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;
}
}
Die übergeordnete Klasse von DialogFactory, die die allgemeine Verarbeitung implementiert.
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 Factory-Klasse. Die übergeordnete build () -Methode ist der Protagonist dieser Klasse. Die Klasse, die AlertDialogFactory erbt, sind die Informationen, die Sie in der build () -Methode anzeigen möchten. Sie müssen lediglich eine Implementierung erstellen, die AlertDialog.Builder erstellt und zurückgibt. Wenn Sie einen anderen Dialog als AlertDialog verwenden möchten, ähnelt dies AlertDialogFactory Erstellen Sie eine übergeordnete Factory. (SingleChoiceDialogFactory oder 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;
}
}
Dialogkörper. Ich mache ungefähr zwei Dinge.
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;
}
}
Erben Sie einfach AlertDialogFactory und implementieren Sie build (). Das Beispiel ist eine einfache Implementierung, aber auch für komplexe Dialoge, die benutzerdefinierte Layouts usw. verwenden. Der Prozess ist in build () implementiert. Auf diese Weise können Sie sich beim Erstellen eines Dialogs darauf konzentrieren, den Inhalt des Dialogs zu erstellen.
-Dialog-Implementierer können sich ausschließlich auf die Implementierung des Codes konzentrieren, der AlertDialog.Builder generiert. Die allgemeine Verarbeitung ist Dialog Generator, AlertDialogFactory, CommonAlertDialog Durch die Implementierung verhält sich der gesamte AlertDialog einheitlich. -Keine Implementierung von Dialog und Show von Dialog direkt in Aktivität Da es lose mit Aktivität gekoppelt ist, sollte es auf der Dialogseite einfacher zu ändern sein als bei der Implementierung in der inneren Klasse.
Es war Qiitas erster Beitrag, aber ich frage mich, ob ein Artikel wie dieser in Ordnung ist. Ich werde weiterhin Artikel durch Ausprobieren veröffentlichen, also hoffe ich, dass Sie mich im Auge behalten.
Quellcode https://github.com/ken-maki/k_commons.dialog