Rappel d'un fragment à partir d'un DialogFragment

Question: Comment créer un rappel d'un DialogFragment vers un autre Fragment. Dans mon cas, l'activité impliquée doit être complètement ignorante du DialogFragment.

Considérez que j'ai

public class MyFragment extends Fragment implements OnClickListener

Puis à un moment donné je pourrais faire

DialogFragment dialogFrag = MyDialogFragment.newInstance(this);
dialogFrag.show(getFragmentManager, null);

À quoi ressemble MyDialogFragment

protected OnClickListener listener;
public static DialogFragment newInstance(OnClickListener listener) {
    DialogFragment fragment = new DialogFragment();
    fragment.listener = listener;
    return fragment;
}

Mais il n'y a aucune garantie que l'écouteur sera là si le DialogFragment s'arrête et reprend tout au long de son cycle de vie. Les seules garanties d'un Fragment sont celles transmises via un Bundle via setArguments et getArguments.

Il existe un moyen de référencer l'activité si ce doit être l'auditeur:

public Dialog onCreateDialog(Bundle bundle) {
    OnClickListener listener = (OnClickListener) getActivity();
    ....
    return new AlertDialog.Builder(getActivity())
        ........
        .setAdapter(adapter, listener)
        .create();
}

Mais je ne veux pas que l'activité écoute les événements, j'ai besoin d'un fragment. Vraiment, il peut s'agir de n'importe quel objet Java implémentant OnClickListener.

Prenons l'exemple concret d'un Fragment qui présente un AlertDialog via DialogFragment. Il a des boutons Oui / Non. Comment puis-je renvoyer ces boutons au fragment qui les a créés?

L'activité impliquée ignore complètement le DialogFragment.

Classe de fragment:

public class MyFragment extends Fragment {
int mStackLevel = 0;
public static final int DIALOG_FRAGMENT = 1;

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    if (savedInstanceState != null) {
        mStackLevel = savedInstanceState.getInt("level");
    }
}

@Override
public void onSaveInstanceState(Bundle outState) {
    super.onSaveInstanceState(outState);
    outState.putInt("level", mStackLevel);
}

void showDialog(int type) {

    mStackLevel++;

    FragmentTransaction ft = getActivity().getFragmentManager().beginTransaction();
    Fragment prev = getActivity().getFragmentManager().findFragmentByTag("dialog");
    if (prev != null) {
        ft.remove(prev);
    }
    ft.addToBackStack(null);

    switch (type) {

        case DIALOG_FRAGMENT:

            DialogFragment dialogFrag = MyDialogFragment.newInstance(123);
            dialogFrag.setTargetFragment(this, DIALOG_FRAGMENT);
            dialogFrag.show(getFragmentManager().beginTransaction(), "dialog");

            break;
    }
}

@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
        switch(requestCode) {
            case DIALOG_FRAGMENT:

                if (resultCode == Activity.RESULT_OK) {
                    // After Ok code.
                } else if (resultCode == Activity.RESULT_CANCELED){
                    // After Cancel code.
                }

                break;
        }
    }
}

}

Classe DialogFragment:

public class MyDialogFragment extends DialogFragment {

public static MyDialogFragment newInstance(int num){

    MyDialogFragment dialogFragment = new MyDialogFragment();
    Bundle bundle = new Bundle();
    bundle.putInt("num", num);
    dialogFragment.setArguments(bundle);

    return dialogFragment;

}

@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {

    return new AlertDialog.Builder(getActivity())
            .setTitle(R.string.ERROR)
            .setIcon(android.R.drawable.ic_dialog_alert)
            .setPositiveButton(R.string.ok_button,
                    new DialogInterface.OnClickListener() {
                        public void onClick(DialogInterface dialog, int whichButton) {
                            getTargetFragment().onActivityResult(getTargetRequestCode(), Activity.RESULT_OK, getActivity().getIntent());
                        }
                    }
            )
            .setNegativeButton(R.string.cancel_button, new DialogInterface.OnClickListener() {
                public void onClick(DialogInterface dialog, int whichButton) {
                    getTargetFragment().onActivityResult(getTargetRequestCode(), Activity.RESULT_CANCELED, getActivity().getIntent());
                }
            })
            .create();
}
}

La solution TargetFragment ne semble pas être la meilleure option pour les fragments de boîte de dialogue, car elle peut se créer IllegalStateExceptionaprès la destruction et la recréation de l'application. Dans ce cas, vous FragmentManagerne trouvez pas le fragment cible et vous obtiendrez IllegalStateExceptionun message comme celui-ci:

"Le fragment n'existe plus pour la clé android: target_state: index 1"

Il semble que ce Fragment#setTargetFragment()n'est pas destiné à la communication entre un enfant et un parent Fragment, mais plutôt à la communication entre frères et sœurs-Fragments.

Une autre façon est donc de créer des fragments de dialogue comme celui-ci en utilisant le ChildFragmentManagerdu fragment parent, plutôt qu'en utilisant les activités FragmentManager:

dialogFragment.show(ParentFragment.this.getChildFragmentManager(), "dialog_fragment");

Et en utilisant une interface, dans la onCreateméthode du, DialogFragmentvous pouvez obtenir le fragment parent:

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    try {
        callback = (Callback) getParentFragment();
    } catch (ClassCastException e) {
        throw new ClassCastException("Calling fragment must implement Callback interface");
    }
}

La seule chose qui reste est d'appeler votre méthode de rappel après ces étapes.

Pour plus d'informations sur le problème, vous pouvez consulter le lien: https://code.google.com/p/android/issues/detail?id=54520

J'ai suivi ces étapes simples pour faire ce genre de choses.

1. Créez une interface comme DialogFragmentCallbackInterfaceavec une méthode comme callBackMethod(Object data). Ce que vous appelleriez pour transmettre des données.
2. Vous pouvez maintenant implémenter une DialogFragmentCallbackInterfaceinterface dans votre fragment commeMyFragment implements DialogFragmentCallbackInterface

3. Au moment de la DialogFragmentcréation, définissez votre fragment appelantMyFragment comme fragment cible qui a créé DialogFragmentutilisez myDialogFragment.setTargetFragment(this, 0)check setTargetFragment (Fragment fragment, int requestCode)

   MyDialogFragment dialogFrag = new MyDialogFragment();
   dialogFrag.setTargetFragment(this, 1); 

4. Obtenez votre objet de fragment cible dans votre DialogFragmenten l'appelant getTargetFragment()et en le DialogFragmentCallbackInterfaceconvertissant en. Vous pouvez maintenant utiliser cette interface pour envoyer des données à votre fragment.

   DialogFragmentCallbackInterface callback = 
              (DialogFragmentCallbackInterface) getTargetFragment();
   callback.callBackMethod(Object data);

   C'est tout fait! assurez-vous simplement que vous avez implémenté cette interface dans votre fragment.

Peut-être un peu tard, mais peut aider d'autres personnes avec la même question que moi.

Vous pouvez utiliser setTargetFragmentsur Dialogavant de montrer, et dans la boîte de dialogue, vous pouvez appeler getTargetFragmentpour obtenir la référence.

Le guide Communiquer avec d'autres fragments indique que les fragments doivent communiquer via l'activité associée .

Vous souhaiterez souvent qu'un fragment communique avec un autre, par exemple pour modifier le contenu en fonction d'un événement utilisateur. Toutes les communications de fragment à fragment se font via l'activité associée. Deux fragments ne doivent jamais communiquer directement.

Vous devez définir un interfacedans votre classe de fragment et implémenter cette interface dans son activité parente. Les détails sont décrits ici http://developer.android.com/guide/components/fragments.html#EventCallbacks . Le code ressemblerait à:

Fragment:

public static class FragmentA extends DialogFragment {

    OnArticleSelectedListener mListener;

    // Container Activity must implement this interface
    public interface OnArticleSelectedListener {
        public void onArticleSelected(Uri articleUri);
    }

    @Override
    public void onAttach(Activity activity) {
        super.onAttach(activity);
        try {
            mListener = (OnArticleSelectedListener) activity;
        } catch (ClassCastException e) {
            throw new ClassCastException(activity.toString() + " must implement OnArticleSelectedListener");
        }
    }
}

Activité:

public class MyActivity extends Activity implements OnArticleSelectedListener{

    ...
    @Override
    public void onArticleSelected(Uri articleUri){

    }
    ...
}

La manière correcte de définir un écouteur sur un fragment est de le définir lorsqu'il est attaché . Le problème que j'ai eu est que onAttachFragment () n'a jamais été appelé. Après quelques recherches, j'ai réalisé que j'avais utilisé getFragmentManager au lieu de getChildFragmentManager

Voici comment je le fais:

MyDialogFragment dialogFragment = MyDialogFragment.newInstance("title", "body");
dialogFragment.show(getChildFragmentManager(), "SOME_DIALOG");

Attachez-le dans onAttachFragment:

@Override
public void onAttachFragment(Fragment childFragment) {
    super.onAttachFragment(childFragment);

    if (childFragment instanceof MyDialogFragment) {
        MyDialogFragment dialog = (MyDialogFragment) childFragment;
        dialog.setListener(new MyDialogFragment.Listener() {
            @Override
            public void buttonClicked() {

            }
        });
    }
}

Selon la documentation officielle:

Fragment # setTargetFragment

Cible facultative pour ce fragment. Cela peut être utilisé, par exemple, si ce fragment est en cours de démarrage par un autre, et une fois terminé, il souhaite renvoyer un résultat au premier. La cible définie ici est conservée dans toutes les instances via FragmentManager # putFragment.

Fragment # getTargetFragment

Renvoie le fragment cible défini par setTargetFragment (Fragment, int).

Vous pouvez donc faire ceci:

// In your fragment

public class MyFragment extends Fragment implements OnClickListener {
    private void showDialog() {
        DialogFragment dialogFrag = MyDialogFragment.newInstance(this);
        // Add this
        dialogFrag.setTargetFragment(this, 0);
        dialogFrag.show(getFragmentManager, null);
    }
    ...
}

// then

public class MyialogFragment extends DialogFragment {
    @Override
    public void onAttach(Context context) {
        super.onAttach(context);
        // Then get it
        Fragment fragment = getTargetFragment();
        if (fragment instanceof OnClickListener) {
            listener = (OnClickListener) fragment;
        } else {
            throw new RuntimeException("you must implement OnClickListener");
        }
    }
    ...
}

J'étais confronté à un problème similaire. La solution que j'ai trouvée était:

1. Déclarez une interface dans votre DialogFragment comme James McCracken l'a expliqué ci-dessus.

2. Implémentez l'interface dans votre activité (pas fragmentée! Ce n'est pas une bonne pratique).

3. À partir de la méthode de rappel de votre activité, appelez une fonction publique requise dans votre fragment qui effectue le travail que vous souhaitez effectuer.

Ainsi, cela devient un processus en deux étapes: DialogFragment -> Activity puis Activity -> Fragment

J'obtiens le résultat vers Fragment DashboardLiveWall (fragment d'appel) de Fragment LiveWallFilterFragment (fragment de réception) Comme ceci ...

 LiveWallFilterFragment filterFragment = LiveWallFilterFragment.newInstance(DashboardLiveWall.this ,"");

 getActivity().getSupportFragmentManager().beginTransaction(). 
 add(R.id.frame_container, filterFragment).addToBackStack("").commit();

où

public static LiveWallFilterFragment newInstance(Fragment targetFragment,String anyDummyData) {
        LiveWallFilterFragment fragment = new LiveWallFilterFragment();
        Bundle args = new Bundle();
        args.putString("dummyKey",anyDummyData);
        fragment.setArguments(args);

        if(targetFragment != null)
            fragment.setTargetFragment(targetFragment, KeyConst.LIVE_WALL_FILTER_RESULT);
        return fragment;
    }

setResult revient à appeler un fragment comme

private void setResult(boolean flag) {
        if (getTargetFragment() != null) {
            Bundle bundle = new Bundle();
            bundle.putBoolean("isWorkDone", flag);
            Intent mIntent = new Intent();
            mIntent.putExtras(bundle);
            getTargetFragment().onActivityResult(getTargetRequestCode(),
                    Activity.RESULT_OK, mIntent);
        }
    }

onActivityResult

@Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);

        if (resultCode == Activity.RESULT_OK) {
            if (requestCode == KeyConst.LIVE_WALL_FILTER_RESULT) {

                Bundle bundle = data.getExtras();
                if (bundle != null) {

                    boolean isReset = bundle.getBoolean("isWorkDone");
                    if (isReset) {

                    } else {
                    }
                }
            }
        }
    }

Actualisé:

J'ai créé une bibliothèque basée sur mon code général qui génère ces castings pour vous en utilisant @CallbackFragmentet @Callback.

https://github.com/zeroarst/callbackfragment .

Et l'exemple vous donne l'exemple qui envoie un rappel d'un fragment à un autre fragment.

Ancienne réponse:

J'ai fait une BaseCallbackFragmentannotation @FragmentCallback. Il s'étend actuellement Fragment, vous pouvez le changer DialogFragmentet fonctionnera. Il vérifie les implémentations dans l'ordre suivant: getTargetFragment ()> getParentFragment ()> context (activité).

Ensuite, il vous suffit de l'étendre et de déclarer vos interfaces dans votre fragment et de lui donner l'annotation, et le fragment de base fera le reste. L'annotation a également un paramètre qui mandatoryvous permet de déterminer si vous souhaitez forcer le fragment à implémenter le rappel.

public class EchoFragment extends BaseCallbackFragment {

    private FragmentInteractionListener mListener;

    @FragmentCallback
    public interface FragmentInteractionListener {
        void onEcho(EchoFragment fragment, String echo);
    }
}

https://gist.github.com/zeroarst/3b3f32092d58698a4568cdb0919c9a93

Les gars de Kotlin, nous y voilà!

Donc, le problème que nous avons est que nous avons créé une activité,, MainActivitysur cette activité, nous avons créé un fragment, FragmentAet maintenant nous voulons créer un fragment de dialogue en plus de l' FragmentAappeler FragmentB. Comment pouvons-nous obtenir les résultats de FragmentBdos à FragmentAsans passer MainActivity?

Remarque:

1. FragmentAest un fragment enfant de MainActivity. Pour gérer les fragments créés dans FragmentAnous utiliserons childFragmentManagerqui fait cela!
2. FragmentAest un fragment parent de FragmentB, pour accéder FragmentAde l'intérieur, FragmentBnous allons utiliser parenFragment.

Cela dit, à l'intérieur FragmentA,

class FragmentA : Fragment(), UpdateNameListener {
    override fun onSave(name: String) {
        toast("Running save with $name")
    }

    // call this function somewhere in a clickListener perhaps
    private fun startUpdateNameDialog() {
        FragmentB().show(childFragmentManager, "started name dialog")
    }
}

Voici le fragment de dialogue FragmentB.

class FragmentB : DialogFragment() {

    private lateinit var listener: UpdateNameListener

    override fun onAttach(context: Context) {
        super.onAttach(context)
        try {
            listener = parentFragment as UpdateNameListener
        } catch (e: ClassCastException) {
            throw ClassCastException("$context must implement UpdateNameListener")
        }
    }

    override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
        return activity?.let {
            val builder = AlertDialog.Builder(it)
            val binding = UpdateNameDialogFragmentBinding.inflate(LayoutInflater.from(context))
            binding.btnSave.setOnClickListener {
                val name = binding.name.text.toString()
                listener.onSave(name)
                dismiss()
            }
            builder.setView(binding.root)
            return builder.create()
        } ?: throw IllegalStateException("Activity can not be null")
    }
}

Voici l'interface qui relie les deux.

interface UpdateNameListener {
    fun onSave(name: String)
}

C'est tout.

J'ai résolu cela de manière élégante avec RxAndroid. Recevoir un observateur dans le constructeur du DialogFragment et souscrire à observable et pousser la valeur lorsque le rappel est appelé. Ensuite, dans votre Fragment, créez une classe interne de l'Observer, créez une instance et passez-la dans le constructeur de DialogFragment. J'ai utilisé WeakReference dans l'observateur pour éviter les fuites de mémoire. Voici le code:

BaseDialogFragment.java

import java.lang.ref.WeakReference;

import io.reactivex.Observer;

public class BaseDialogFragment<O> extends DialogFragment {

    protected WeakReference<Observer<O>> observerRef;

    protected BaseDialogFragment(Observer<O> observer) {
        this.observerRef = new WeakReference<>(observer);
   }

    protected Observer<O> getObserver() {
    return observerRef.get();
    }
}

DatePickerFragment.java

public class DatePickerFragment extends BaseDialogFragment<Integer>
    implements DatePickerDialog.OnDateSetListener {


public DatePickerFragment(Observer<Integer> observer) {
    super(observer);
}

@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
    // Use the current date as the default date in the picker
    final Calendar c = Calendar.getInstance();
    int year = c.get(Calendar.YEAR);
    int month = c.get(Calendar.MONTH);
    int day = c.get(Calendar.DAY_OF_MONTH);

    // Create a new instance of DatePickerDialog and return it
    return new DatePickerDialog(getActivity(), this, year, month, day);
}

@Override
public void onDateSet(DatePicker view, int year, int month, int dayOfMonth) {
        if (getObserver() != null) {
            Observable.just(month).subscribe(getObserver());
        }
    }
}

MyFragment.java

//Show the dialog fragment when the button is clicked
@OnClick(R.id.btn_date)
void onDateClick() {
    DialogFragment newFragment = new DatePickerFragment(new OnDateSelectedObserver());
    newFragment.show(getFragmentManager(), "datePicker");
}
 //Observer inner class
 private class OnDateSelectedObserver implements Observer<Integer> {

    @Override
    public void onSubscribe(Disposable d) {

    }

    @Override
    public void onNext(Integer integer) {
       //Here you invoke the logic

    }

    @Override
    public void onError(Throwable e) {

    }

    @Override
    public void onComplete() {

    }
}

Vous pouvez voir le code source ici: https://github.com/andresuarezz26/carpoolapp