Panggilan balik ke Fragmen dari DialogFragment

Pertanyaan: Bagaimana cara membuat panggilan balik dari DialogFragment ke Fragmen lain. Dalam kasus saya, Aktivitas yang terlibat harus benar-benar tidak menyadari DialogFragment.

Anggap saja sudah

public class MyFragment extends Fragment implements OnClickListener

Kemudian pada titik tertentu saya bisa melakukannya

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

Di mana MyDialogFragment terlihat seperti

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

Tetapi tidak ada jaminan bahwa pendengar akan ada jika DialogFragment berhenti dan dilanjutkan melalui siklus hidupnya. Satu-satunya jaminan dalam Fragmen adalah yang diteruskan melalui Bundel melalui setArguments dan getArguments.

Ada cara untuk merujuk aktivitas jika harus menjadi pendengar:

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

Tapi saya tidak ingin Kegiatan mendengarkan acara, saya butuh Fragmen. Sungguh, itu bisa berupa objek Java yang mengimplementasikan OnClickListener.

Pertimbangkan contoh konkret dari Fragmen yang menyajikan AlertDialog melalui DialogFragment. Ini memiliki tombol Ya / Tidak. Bagaimana saya bisa mengirim tombol ini menekan kembali ke Fragmen yang membuatnya?

Aktivitas yang terlibat sama sekali tidak menyadari DialogFragment.

Kelas fragmen:

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

}

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

Solusi TargetFragment tampaknya bukan pilihan terbaik untuk fragmen dialog karena mungkin dibuat IllegalStateExceptionsetelah aplikasi dihancurkan dan diciptakan kembali. Dalam hal ini FragmentManagertidak dapat menemukan fragmen target dan Anda akan mendapatkan IllegalStateExceptiondengan pesan seperti ini:

"Fragmen tidak ada lagi untuk kunci android: target_state: index 1"

Sepertinya Fragment#setTargetFragment()tidak dimaksudkan untuk komunikasi antara Fragmen anak dan orang tua, melainkan untuk komunikasi antara saudara kandung Fragmen.

Jadi cara alternatif adalah membuat fragmen dialog seperti ini dengan menggunakan ChildFragmentManagerfragmen induk, daripada menggunakan aktivitas FragmentManager:

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

Dan dengan menggunakan Antarmuka, dalam onCreatemetode DialogFragmentAnda bisa mendapatkan fragmen induk:

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

Satu-satunya yang tersisa adalah memanggil metode panggilan balik Anda setelah langkah-langkah ini.

Untuk informasi lebih lanjut tentang masalah ini, Anda dapat memeriksa tautannya: https://code.google.com/p/android/issues/detail?id=54520

Saya mengikuti langkah-langkah sederhana ini untuk melakukan hal ini.

1. Buat antarmuka seperti DialogFragmentCallbackInterfacedengan beberapa metode seperti callBackMethod(Object data). Yang akan Anda panggil untuk meneruskan data.
2. Sekarang Anda dapat mengimplementasikan DialogFragmentCallbackInterfaceantarmuka dalam fragmen Anda sepertiMyFragment implements DialogFragmentCallbackInterface

3. Pada saat DialogFragmentpembuatan, tetapkan fragmen pemanggilan Anda MyFragmentsebagai fragmen target yang dibuat DialogFragmentmenggunakan myDialogFragment.setTargetFragment(this, 0)cek setTargetFragment (Fragmen fragmen, int requestCode)

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

4. Dapatkan objek fragmen target Anda ke Anda DialogFragmentdengan menelepon getTargetFragment()dan melemparkannya ke DialogFragmentCallbackInterface. Sekarang Anda dapat menggunakan antarmuka ini untuk mengirim data ke fragmen Anda.

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

   Itu semua dilakukan! pastikan Anda telah mengimplementasikan antarmuka ini dalam fragmen Anda.

Mungkin agak terlambat, tetapi dapat membantu orang lain dengan pertanyaan yang sama seperti yang saya lakukan.

Anda dapat menggunakan setTargetFragmentpada Dialogsebelum ditampilkan, dan dalam dialog Anda dapat menelepon getTargetFragmentuntuk mendapatkan referensi.

Panduan Berkomunikasi dengan Fragmen Lain mengatakan Fragmen harus berkomunikasi melalui Aktivitas terkait .

Seringkali Anda ingin satu Fragmen untuk berkomunikasi dengan yang lain, misalnya untuk mengubah konten berdasarkan peristiwa pengguna. Semua komunikasi Fragmen-ke-Fragmen dilakukan melalui Aktivitas terkait. Dua Fragmen tidak boleh berkomunikasi secara langsung.

Anda harus mendefinisikan sebuah interfacedi kelas fragmen Anda dan mengimplementasikan antarmuka itu dalam aktivitas induknya. Detailnya diuraikan di sini http://developer.android.com/guide/components/fragments.html#EventCallbacks . Kode akan terlihat mirip dengan:

Pecahan:

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

Aktivitas:

public class MyActivity extends Activity implements OnArticleSelectedListener{

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

    }
    ...
}

Cara yang benar untuk mengatur pendengar ke sebuah fragmen adalah dengan menyetelnya ketika itu dilampirkan . Masalah yang saya miliki adalah bahwa onAttachFragment () tidak pernah dipanggil. Setelah beberapa penyelidikan saya menyadari bahwa saya telah menggunakan getFragmentManager daripada getChildFragmentManager

Inilah cara saya melakukannya:

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

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

            }
        });
    }
}

Menurut dokumentasi resmi:

Fragmen # setTargetFragment

Target opsional untuk fragmen ini. Ini dapat digunakan, misalnya, jika fragmen ini sedang dimulai oleh yang lain, dan ketika selesai ingin memberikan hasil kembali ke yang pertama. Target yang ditetapkan di sini dipertahankan di seluruh instance melalui FragmentManager # putFragment.

Fragmen # getTargetFragment

Kembalikan fragmen target yang ditetapkan oleh setTargetFragment (Fragment, int).

Jadi Anda bisa melakukan ini:

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

Saya menghadapi masalah yang sama. Solusi yang saya temukan adalah:

1. Deklarasikan antarmuka di DialogFragment Anda seperti yang dijelaskan James McCracken di atas.

2. Terapkan antarmuka dalam aktivitas Anda (bukan fragmen! Itu bukan praktik yang baik).

3. Dari metode panggilan balik dalam aktivitas Anda, panggil fungsi publik yang diperlukan dalam fragmen Anda yang melakukan pekerjaan yang ingin Anda lakukan.

Dengan demikian, itu menjadi proses dua langkah: DialogFragment -> Activity dan kemudian Activity -> Fragment

Saya mendapatkan hasil untuk Dashboard FragmenLiveWall (memanggil fragmen) dari Fragment LiveWallFilterFragment (menerima fragmen) Seperti ini ...

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

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

dimana

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 kembali ke memanggil fragmen suka

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

Diperbarui:

Saya membuat perpustakaan berdasarkan kode inti saya yang menghasilkan casting untuk Anda dengan menggunakan @CallbackFragmentdan @Callback.

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

Dan contoh memberi Anda contoh yang mengirim panggilan balik dari sebuah fragmen ke fragmen lain.

Jawaban lama:

Saya membuat BaseCallbackFragmentdan membuat anotasi @FragmentCallback. Saat ini meluas Fragment, Anda dapat mengubahnya ke DialogFragmentdan akan bekerja. Ia memeriksa implementasi dengan urutan berikut: getTargetFragment ()> getParentFragment ()> konteks (aktivitas).

Maka Anda hanya perlu memperluas dan mendeklarasikan antarmuka Anda dalam fragmen Anda dan memberikan penjelasannya, dan fragmen dasar akan melakukan sisanya. Anotasi juga memiliki parameter mandatoryuntuk Anda menentukan apakah Anda ingin memaksa fragmen untuk mengimplementasikan panggilan balik.

public class EchoFragment extends BaseCallbackFragment {

    private FragmentInteractionListener mListener;

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

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

Kawan Kotlin, kita mulai!

Jadi masalah yang kita miliki adalah bahwa kita menciptakan suatu kegiatan,, MainActivitypada aktivitas itu kita menciptakan sebuah fragmen, FragmentAdan sekarang kita ingin membuat fragmen dialog FragmentAselain menyebutnya FragmentB. Bagaimana kita mendapatkan hasil dari FragmentBbelakang FragmentAtanpa melalui MainActivity?

catatan:

1. FragmentAadalah fragmen anak MainActivity. Untuk mengelola fragmen yang dibuat di FragmentAkami akan menggunakan childFragmentManageryang melakukannya!
2. FragmentAadalah fragmen induk dari FragmentB, untuk mengakses FragmentAdari dalam FragmentBkita akan menggunakan parenFragment.

Karena itu, di dalam 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")
    }
}

Inilah fragmen dialognya 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")
    }
}

Berikut ini antarmuka yang menghubungkan keduanya.

interface UpdateNameListener {
    fun onSave(name: String)
}

Itu dia.

Saya memecahkan ini dengan cara yang elegan dengan RxAndroid. Menerima pengamat di konstruktor DialogFragment dan mendaftar untuk diamati dan mendorong nilai ketika panggilan balik dipanggil. Kemudian, di Fragmen Anda, buat kelas bagian dalam Observer, buat instance dan berikan dalam konstruktor DialogFragment. Saya menggunakan WeakReference di pengamat untuk menghindari kebocoran memori. Ini kodenya:

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

    }
}

Anda dapat melihat kode sumber di sini: https://github.com/andresuarezz26/carpoolingapp