Rückruf auf ein Fragment aus einem DialogFragment

Frage: Wie erstellt man einen Rückruf von einem DialogFragment zu einem anderen Fragment? In meinem Fall sollte die betreffende Aktivität das DialogFragment überhaupt nicht kennen.

Betrachten Sie ich habe

public class MyFragment extends Fragment implements OnClickListener

Dann könnte ich irgendwann tun

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

Wo MyDialogFragment aussieht

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

Es gibt jedoch keine Garantie dafür, dass der Listener verfügbar ist, wenn das DialogFragment angehalten und während seines Lebenszyklus fortgesetzt wird. Die einzigen Garantien in einem Fragment sind diejenigen, die über setArguments und getArguments durch ein Bundle übergeben werden.

Es gibt eine Möglichkeit, auf die Aktivität zu verweisen, wenn es sich um den Listener handeln soll:

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

Aber ich möchte nicht, dass die Aktivität auf Ereignisse wartet, ich brauche ein Fragment. Wirklich, es könnte jedes Java-Objekt sein, das OnClickListener implementiert.

Betrachten Sie das konkrete Beispiel eines Fragments, das einen AlertDialog über DialogFragment darstellt. Es hat Ja / Nein-Tasten. Wie kann ich diese Tastendrücke an das Fragment zurücksenden, das sie erstellt hat?

Die beteiligten Aktivitäten kennen das DialogFragment überhaupt nicht.

Fragmentklasse:

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;
        }
    }
}

}

DialogFragment-Klasse:

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();
}
}

Die TargetFragment-Lösung scheint nicht die beste Option für Dialogfragmente zu sein, da sie möglicherweise erstellt wird, IllegalStateExceptionnachdem die Anwendung zerstört und neu erstellt wurde. In diesem Fall FragmentManagerkonnte das Zielfragment nicht gefunden werden und Sie erhalten IllegalStateExceptioneine Meldung wie die folgende:

"Fragment existiert nicht mehr für Schlüssel android: target_state: index 1"

Es scheint Fragment#setTargetFragment()nicht für die Kommunikation zwischen einem Kind und einem Elternfragment gedacht zu sein, sondern für die Kommunikation zwischen Geschwisterfragmenten.

Eine alternative Möglichkeit besteht darin, Dialogfragmente wie dieses mithilfe ChildFragmentManagerdes übergeordneten Fragments zu erstellen , anstatt die folgenden Aktivitäten zu verwenden FragmentManager:

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

Und mithilfe einer Schnittstelle können Sie in der onCreateMethode von DialogFragmentdas übergeordnete Fragment erhalten:

@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");
    }
}

Nach diesen Schritten müssen Sie nur noch Ihre Rückrufmethode aufrufen.

Weitere Informationen zu diesem Problem finden Sie unter folgendem Link: https://code.google.com/p/android/issues/detail?id=54520

Ich habe diese einfachen Schritte befolgt, um dieses Zeug zu machen.

1. Erstellen Sie eine Schnittstelle wie DialogFragmentCallbackInterfacemit einer Methode wie callBackMethod(Object data). Welche würden Sie anrufen, um Daten zu übergeben.
2. Jetzt können Sie DialogFragmentCallbackInterfaceSchnittstelle in Ihrem Fragment wie implementierenMyFragment implements DialogFragmentCallbackInterface

3. Zum Zeitpunkt der DialogFragmentErstellung legen Sie Ihr aufrufendes Fragment MyFragmentals Zielfragment fest , das DialogFragmentmithilfe von myDialogFragment.setTargetFragment(this, 0)check setTargetFragment (Fragmentfragment, int requestCode) erstellt wurde.

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

4. Holen Sie sich Ihr Zielfragmentobjekt in Ihr Objekt, DialogFragmentindem Sie es aufrufen getTargetFragment()und in DialogFragmentCallbackInterface.Nun umwandeln. Jetzt können Sie diese Schnittstelle verwenden, um Daten an Ihr Fragment zu senden.

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

   Das ist alles erledigt! Stellen Sie einfach sicher, dass Sie diese Schnittstelle in Ihrem Fragment implementiert haben.

Vielleicht etwas spät, kann aber anderen Menschen bei der gleichen Frage helfen wie ich.

Sie können setTargetFragmenton Dialogvor dem Anzeigen verwenden und im Dialogfeld aufrufen getTargetFragment, um die Referenz abzurufen.

Der Leitfaden Kommunikation mit anderen Fragmenten besagt, dass die Fragmente über die zugehörige Aktivität kommunizieren sollten .

Oft möchten Sie, dass ein Fragment mit einem anderen kommuniziert, um beispielsweise den Inhalt basierend auf einem Benutzerereignis zu ändern. Die gesamte Kommunikation von Fragment zu Fragment erfolgt über die zugehörige Aktivität. Zwei Fragmente sollten niemals direkt kommunizieren.

Sie sollten eine interfacein Ihrer Fragmentklasse definieren und diese Schnittstelle in ihrer übergeordneten Aktivität implementieren. Die Details finden Sie hier http://developer.android.com/guide/components/fragments.html#EventCallbacks . Der Code würde ähnlich aussehen wie:

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");
        }
    }
}

Aktivität:

public class MyActivity extends Activity implements OnArticleSelectedListener{

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

    }
    ...
}

Die richtige Methode zum Festlegen eines Listeners für ein Fragment besteht darin, es beim Anhängen festzulegen . Das Problem, das ich hatte, war, dass onAttachFragment () nie aufgerufen wurde. Nach einigen Nachforschungen stellte ich fest, dass ich getFragmentManager anstelle von getChildFragmentManager verwendet hatte

So mache ich das:

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

Fügen Sie es in onAttachFragment hinzu:

@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() {

            }
        });
    }
}

Laut offizieller Dokumentation:

Fragment # setTargetFragment

Optionales Ziel für dieses Fragment. Dies kann beispielsweise verwendet werden, wenn dieses Fragment von einem anderen gestartet wird und wenn dies erledigt ist, dem ersten ein Ergebnis zurückgegeben werden soll. Das hier festgelegte Ziel wird über FragmentManager # putFragment instanzübergreifend beibehalten.

Fragment # getTargetFragment

Gibt das von setTargetFragment (Fragment, int) festgelegte Zielfragment zurück.

So können Sie Folgendes tun:

// 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");
        }
    }
    ...
}

Ich hatte ein ähnliches Problem. Die Lösung, die ich herausfand, war:

1. Deklarieren Sie eine Schnittstelle in Ihrem DialogFragment, wie James McCracken oben erklärt hat.

2. Implementieren Sie die Schnittstelle in Ihrer Aktivität (kein Fragment! Dies ist keine gute Vorgehensweise).

3. Rufen Sie über die Rückrufmethode in Ihrer Aktivität eine erforderliche öffentliche Funktion in Ihrem Fragment auf, die den gewünschten Job ausführt.

Somit wird es ein zweistufiger Prozess: DialogFragment -> Aktivität und dann Aktivität -> Fragment

Ich erhalte ein Ergebnis für Fragment DashboardLiveWall (aufrufendes Fragment) von Fragment LiveWallFilterFragment (empfangendes Fragment).

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

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

wo

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 zurück zum Aufrufen von Fragmenten wie

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 {
                    }
                }
            }
        }
    }

Aktualisiert:

Ich habe eine Bibliothek basierend auf meinem Kerncode erstellt, die diese Castings mit @CallbackFragmentund für Sie generiert @Callback.

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

Das Beispiel zeigt das Beispiel, in dem ein Rückruf von einem Fragment an ein anderes Fragment gesendet wird.

Alte Antwort:

Ich habe eine BaseCallbackFragmentund Anmerkung gemacht @FragmentCallback. Es wird derzeit erweitert Fragment, Sie können es ändern DialogFragmentund es wird funktionieren. Es überprüft die Implementierungen in der folgenden Reihenfolge: getTargetFragment ()> getParentFragment ()> context (Aktivität).

Dann müssen Sie es nur noch erweitern und Ihre Schnittstellen in Ihrem Fragment deklarieren und ihm die Anmerkung geben, und das Basisfragment erledigt den Rest. Die Anmerkung enthält auch einen Parameter, mandatorymit dem Sie bestimmen können, ob Sie das Fragment zwingen möchten, den Rückruf zu implementieren.

public class EchoFragment extends BaseCallbackFragment {

    private FragmentInteractionListener mListener;

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

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

Kotlin Jungs hier gehen wir!

Das Problem, das wir haben, ist, dass wir eine Aktivität erstellt haben MainActivity, für diese Aktivität ein Fragment erstellt haben FragmentAund jetzt ein Dialogfragment zusätzlich zum FragmentAAufruf erstellen möchten FragmentB. Wie bekommen wir die Ergebnisse von FragmentBzurück zu FragmentAohne durchzugehen MainActivity?

Hinweis:

1. FragmentAist ein Kinderfragment von MainActivity. Um die in erstellten Fragmente zu verwalten, verwenden FragmentAwir das, childFragmentManagerwas das tut!
2. FragmentAist ein übergeordnetes Fragment von FragmentB, auf das wir FragmentAvon innen zugreifen FragmentBwerden parenFragment.

Having said that, innen 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")
    }
}

Hier ist das Dialogfragment 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")
    }
}

Hier ist die Schnittstelle, die die beiden verbindet.

interface UpdateNameListener {
    fun onSave(name: String)
}

Das ist es.

Ich habe dies auf elegante Weise mit RxAndroid gelöst. Empfangen Sie einen Beobachter im Konstruktor des DialogFragments und abonnieren Sie Observable und drücken Sie den Wert, wenn der Rückruf aufgerufen wird. Erstellen Sie dann in Ihrem Fragment eine innere Klasse des Beobachters, erstellen Sie eine Instanz und übergeben Sie sie im Konstruktor des DialogFragments. Ich habe WeakReference im Observer verwendet, um Speicherverluste zu vermeiden. Hier ist der 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() {

    }
}

Sie können den Quellcode hier sehen: https://github.com/andresuarezz26/carpoolingapp