Wywołanie zwrotne do fragmentu z DialogFragment

Pytanie: W jaki sposób można utworzyć wywołanie zwrotne z DialogFragment do innego fragmentu. W moim przypadku, zaangażowana aktywność powinna być całkowicie nieświadoma DialogFragment.

Rozważ, że mam

public class MyFragment extends Fragment implements OnClickListener

Wtedy w pewnym momencie mogłem to zrobić

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

Gdzie wygląda MyDialogFragment

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

Ale nie ma gwarancji, że odbiornik będzie w pobliżu, jeśli DialogFragment zostanie wstrzymana i wznowiona przez cały cykl życia. Jedyne gwarancje we fragmencie to te przekazywane przez Bundle za pośrednictwem setArguments i getArguments.

Istnieje sposób odniesienia się do działania, jeśli powinien to być słuchacz:

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

Ale nie chcę, aby działanie nasłuchiwało wydarzeń, potrzebuję fragmentu. Naprawdę może to być dowolny obiekt Java, który implementuje OnClickListener.

Rozważ konkretny przykład fragmentu, który przedstawia AlertDialog za pośrednictwem DialogFragment. Posiada przyciski Tak / Nie. Jak mogę wysłać te naciśnięcia przycisku z powrotem do fragmentu, który go utworzył?

Aktywność zaangażowana jest całkowicie nieświadoma DialogFragment.

Klasa fragmentu:

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, klasa:

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

Rozwiązanie TargetFragment nie wydaje się najlepszą opcją dla fragmentów okien dialogowych, ponieważ może powstać IllegalStateExceptionpo zniszczeniu i odtworzeniu aplikacji. W tym przypadku FragmentManagernie udało się znaleźć fragmentu docelowego, a otrzymasz IllegalStateExceptionwiadomość taką jak ta:

„Fragment już nie istnieje dla klucza android: target_state: index 1”

Wygląda na Fragment#setTargetFragment()to, że nie jest przeznaczony do komunikacji między dzieckiem a fragmentem rodzica, ale raczej do komunikacji między fragmentami rodzeństwa.

Tak więc alternatywnym sposobem jest tworzenie fragmentów dialogów, takich jak ten, używając ChildFragmentManagerfragmentu nadrzędnego, a nie działań FragmentManager:

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

Korzystając z interfejsu, w onCreatemetodzie DialogFragmentmożna pobrać fragment nadrzędny:

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

Pozostaje tylko wywołać metodę wywołania zwrotnego po wykonaniu tych czynności.

Aby uzyskać więcej informacji na temat problemu, możesz sprawdzić link: https://code.google.com/p/android/issues/detail?id=54520

Wykonałem te proste kroki, aby to zrobić.

1. Utwórz interfejs jak w DialogFragmentCallbackInterfaceprzypadku niektórych metod, takich jak callBackMethod(Object data). Do którego dzwonisz, aby przekazać dane.
2. Teraz możesz zaimplementować DialogFragmentCallbackInterfaceinterfejs w swoim fragmencie, npMyFragment implements DialogFragmentCallbackInterface

3. W momencie DialogFragmenttworzenia ustaw swój wywołujący fragment MyFragmentjako fragment docelowy, który utworzył DialogFragmentużyj myDialogFragment.setTargetFragment(this, 0)check setTargetFragment (fragment fragmentu, int requestCode)

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

4. Pobierz docelowy obiekt fragmentu do swojego DialogFragment, wywołując go getTargetFragment()i rzucając do. DialogFragmentCallbackInterfaceTeraz możesz użyć tego interfejsu do wysłania danych do swojego fragmentu.

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

   To wszystko gotowe! po prostu upewnij się, że zaimplementowałeś ten interfejs w swoim fragmencie.

Może trochę późno, ale może pomóc innym ludziom z tym samym pytaniem, co ja.

Możesz użyć setTargetFragmenton Dialogprzed pokazaniem, aw oknie dialogowym możesz zadzwonić, getTargetFragmentaby uzyskać odniesienie.

Przewodnik dotyczący komunikacji z innymi fragmentami mówi, że fragmenty powinny komunikować się za pośrednictwem powiązanego działania .

Często chcesz, aby jeden fragment komunikował się z innym, na przykład w celu zmiany treści na podstawie zdarzenia użytkownika. Cała komunikacja między fragmentami odbywa się za pośrednictwem powiązanego działania. Dwa fragmenty nigdy nie powinny komunikować się bezpośrednio.

Powinieneś zdefiniować interfacew swojej klasie fragmentu i zaimplementować ten interfejs w jego aktywności nadrzędnej. Szczegóły opisano tutaj http://developer.android.com/guide/components/fragments.html#EventCallbacks . Kod wyglądałby podobnie do:

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

Czynność:

public class MyActivity extends Activity implements OnArticleSelectedListener{

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

    }
    ...
}

Prawidłowym sposobem przypisania słuchacza do fragmentu jest ustawienie go w momencie dołączenia . Problem polegał na tym, że onAttachFragment () nigdy nie został wywołany. Po pewnym dochodzeniu zdałem sobie sprawę, że używałem getFragmentManager zamiast getChildFragmentManager

Oto jak to robię:

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

Dołącz go w 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() {

            }
        });
    }
}

Według oficjalnej dokumentacji:

Fragment # setTargetFragment

Opcjonalny cel dla tego fragmentu. Można to wykorzystać na przykład, jeśli ten fragment jest uruchamiany przez inny, a po zakończeniu chce zwrócić wynik do pierwszego. Ustawiony tutaj cel jest zachowywany między instancjami za pośrednictwem FragmentManager # putFragment.

Fragment # getTargetFragment

Zwróć fragment docelowy ustawiony przez setTargetFragment (Fragment, int).

Więc możesz to zrobić:

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

Miałem podobny problem. Rozwiązanie, które znalazłem to:

1. Zadeklaruj interfejs w swoim DialogFragment, tak jak wyjaśnił James McCracken powyżej.

2. Zaimplementuj interfejs w swoim działaniu (nie fragment! To nie jest dobra praktyka).

3. Z metody wywołania zwrotnego w twoim działaniu, wywołaj wymaganą funkcję publiczną w swoim fragmencie, która wykonuje zadanie, które chcesz wykonać.

W ten sposób staje się procesem dwuetapowym: DialogFragment -> Aktywność, a następnie Aktywność -> Fragment

Otrzymuję wynik do Fragment DashboardLiveWall (wywołujący fragment) z Fragment LiveWallFilterFragment (odbierający fragment) W ten sposób ...

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

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

gdzie

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 z powrotem do wywołania fragmentu takiego jak

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

Zaktualizowano:

Stworzyłem bibliotekę opartą na moim głównym kodzie, który generuje te odlewania za pomocą @CallbackFragmenti @Callback.

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

A przykład daje przykład, który wysyła wywołanie zwrotne z fragmentu do innego fragmentu.

Stara odpowiedź:

Zrobiłem BaseCallbackFragmenti adnotację @FragmentCallback. Obecnie się rozszerza Fragment, możesz go zmienić naDialogFragment i będzie działać. Sprawdza implementacje w następującej kolejności: getTargetFragment ()> getParentFragment ()> kontekst (aktywność).

Następnie wystarczy go rozszerzyć i zadeklarować interfejsy w swoim fragmencie i nadać mu adnotację, a fragment podstawowy zrobi resztę. Adnotacja zawiera również parametr mandatoryumożliwiający określenie, czy chcesz wymusić na fragmencie zaimplementowanie wywołania zwrotnego.

public class EchoFragment extends BaseCallbackFragment {

    private FragmentInteractionListener mListener;

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

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

Chłopaki Kotlin, zaczynamy!

Więc problem polega na tym, że stworzyliśmy działanie, MainActivityw ramach tego działania utworzyliśmy fragment, FragmentAa teraz chcemy utworzyć fragment okna dialogowego, FragmentAaby go nazwać FragmentB. Jak uzyskać wyniki z FragmentBpowrotem do FragmentAbez przechodzenia przezMainActivity ?

Uwaga:

1. FragmentAjest fragmentem podrzędnym MainActivity. Do zarządzania utworzonymi w programie fragmentami FragmentAużyjemy tego, childFragmentManagerktóry to robi!
2. FragmentAjest fragmentem nadrzędnym FragmentB, do którego dostępu FragmentAod wewnątrz FragmentBużyjemy parenFragment.

Mimo, że w środku 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")
    }
}

Oto fragment okna dialogowego 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")
    }
}

Oto interfejs łączący oba.

interface UpdateNameListener {
    fun onSave(name: String)
}

Otóż ​​to.

Rozwiązałem to w elegancki sposób z RxAndroid. Odbierz obserwatora w konstruktorze DialogFragment i zasubskrybuj obserwowalne i wypchnij wartość, gdy wywoływane jest wywołanie zwrotne. Następnie w swoim fragmencie utwórz wewnętrzną klasę Observer, utwórz instancję i przekaż ją do konstruktora DialogFragment. Użyłem WeakReference w obserwatorze, aby uniknąć wycieków pamięci. Oto kod:

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

    }
}

Możesz zobaczyć kod źródłowy tutaj: https://github.com/andresuarezz26/carpoolingapp