Devolución de llamada a un fragmento desde un fragmento de diálogo

Pregunta: ¿Cómo se crea una devolución de llamada de un DialogFragment a otro Fragment? En mi caso, la actividad involucrada debe ser completamente inconsciente del DialogFragment.

Considera que tengo

public class MyFragment extends Fragment implements OnClickListener

Entonces en algún momento podría hacer

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

Donde se ve MyDialogFragment

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

Pero no hay garantía de que el oyente estará presente si DialogFragment hace una pausa y se reanuda durante su ciclo de vida. Las únicas garantías en un Fragmento son las que se pasan a través de un Paquete a través de setArguments y getArguments.

Hay una manera de hacer referencia a la actividad si debería ser el oyente:

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

Pero no quiero que la Actividad escuche eventos, necesito un Fragmento. Realmente, podría ser cualquier objeto Java que implemente OnClickListener.

Considere el ejemplo concreto de un Fragmento que presenta un AlertDialog a través de DialogFragment. Tiene botones Sí / No. ¿Cómo puedo enviar estas pulsaciones de botón al Fragmento que lo creó?

La actividad involucrada desconoce completamente el DialogFragment.

Clase de fragmento:

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

}

Clase 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 solución TargetFragment no parece la mejor opción para fragmentos de diálogo porque puede crearse IllegalStateExceptiondespués de que la aplicación se destruya y se vuelva a crear. En este caso FragmentManagerno pudo encontrar el fragmento de destino y recibirá un IllegalStateExceptionmensaje como este:

"El fragmento ya no existe para Android clave: target_state: índice 1"

Parece que Fragment#setTargetFragment()no está destinado a la comunicación entre un Fragmento de padres e hijos, sino más bien a la comunicación entre Fragmentos de hermanos.

Entonces, una forma alternativa es crear fragmentos de diálogo como este mediante el uso del ChildFragmentManagerfragmento principal, en lugar de utilizar las actividades FragmentManager:

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

Y al usar una interfaz, en el onCreatemétodo de DialogFragmentpuede obtener el fragmento primario:

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

Lo único que queda es llamar a su método de devolución de llamada después de estos pasos.

Para obtener más información sobre el problema, puede consultar el enlace: https://code.google.com/p/android/issues/detail?id=54520

Seguí estos simples pasos para hacer esto.

1. Crear interfaz como DialogFragmentCallbackInterfacecon algún método como callBackMethod(Object data). Que llamarías para pasar datos.
2. Ahora puede implementar la DialogFragmentCallbackInterfaceinterfaz en su fragmento comoMyFragment implements DialogFragmentCallbackInterface

3. En el momento de la DialogFragmentcreación, configure su fragmento de invocación MyFragmentcomo fragmento de destino que creó DialogFragmentusando myDialogFragment.setTargetFragment(this, 0)check setTargetFragment (Fragment fragment, int requestCode)

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

4. Obtenga su objeto de fragmento de destino en su DialogFragmentllamada getTargetFragment()y DialogFragmentCallbackInterfaceenvíelo a . Ahora puede usar esta interfaz para enviar datos a su fragmento.

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

   Eso es todo hecho! solo asegúrese de haber implementado esta interfaz en su fragmento.

Tal vez un poco tarde, pero puede ayudar a otras personas con la misma pregunta que yo hice.

Puede usar setTargetFragmenton Dialogantes de mostrar, y en el diálogo puede llamar getTargetFragmentpara obtener la referencia.

La guía de Comunicación con otros fragmentos dice que los fragmentos deben comunicarse a través de la actividad asociada .

A menudo, querrá que un Fragmento se comunique con otro, por ejemplo, para cambiar el contenido en función de un evento del usuario. Toda la comunicación Fragmento a Fragmento se realiza a través de la Actividad asociada. Dos fragmentos nunca deben comunicarse directamente.

Debe definir un interfaceen su clase de fragmento e implementar esa interfaz en su actividad principal. Los detalles se describen aquí http://developer.android.com/guide/components/fragments.html#EventCallbacks . El código sería similar a:

Fragmento:

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

Actividad:

public class MyActivity extends Activity implements OnArticleSelectedListener{

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

    }
    ...
}

La forma correcta de configurar un oyente para un fragmento es configurándolo cuando está adjunto . El problema que tuve fue que onAttachFragment () nunca fue llamado. Después de investigar un poco, me di cuenta de que había estado usando getFragmentManager en lugar de getChildFragmentManager

Así es como lo hago:

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

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

            }
        });
    }
}

Según la documentación oficial:

Fragmento # setTargetFragment

Objetivo opcional para este fragmento. Esto se puede usar, por ejemplo, si este fragmento está siendo iniciado por otro, y cuando se hace quiere devolver el resultado al primero. El objetivo establecido aquí se retiene en todas las instancias a través de FragmentManager # putFragment.

Fragmento # getTargetFragment

Devuelve el fragmento de destino establecido por setTargetFragment (Fragment, int).

Entonces puedes hacer esto:

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

Estaba enfrentando un problema similar. La solución que descubrí fue:

1. Declare una interfaz en su DialogFragment tal como James McCracken ha explicado anteriormente.

2. Implemente la interfaz en su actividad (¡no fragmente! Esa no es una buena práctica).

3. Desde el método de devolución de llamada en su actividad, llame a una función pública requerida en su fragmento que hace el trabajo que desea hacer.

Por lo tanto, se convierte en un proceso de dos pasos: DialogFragment -> Activity y luego Activity -> Fragment

Estoy obteniendo el resultado de Fragment DashboardLiveWall (fragmento de llamada) de Fragment LiveWallFilterFragment (fragmento de recepción) De esta manera ...

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

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

dónde

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 vuelve a llamar al fragmento como

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

Actualizado:

Hice una biblioteca basada en mi código esencial que genera esos castings para ti usando @CallbackFragmenty @Callback.

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

Y el ejemplo le da el ejemplo que envía una devolución de llamada de un fragmento a otro fragmento.

Vieja respuesta:

Hice una BaseCallbackFragmentanotación @FragmentCallback. Actualmente se extiende Fragment, puede cambiarlo aDialogFragment y funcionará. Comprueba las implementaciones en el siguiente orden: getTargetFragment ()> getParentFragment ()> context (activity).

Luego solo necesita extenderlo y declarar sus interfaces en su fragmento y darle la anotación, y el fragmento base hará el resto. La anotación también tiene un parámetro mandatorypara determinar si desea forzar el fragmento a implementar la devolución de llamada.

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 chicos aquí vamos!

Entonces, el problema que tenemos es que creamos una actividad, MainActivityen esa actividad creamos un fragmento, FragmentAy ahora queremos crear un fragmento de diálogo además de FragmentAllamarlo FragmentB. ¿Cómo obtenemos los resultados desde FragmentBatrás hasta FragmentAsin pasar porMainActivity ?

Nota:

1. FragmentAes un fragmento infantil de MainActivity. Para gestionar los fragmentos creados FragmentA, usaremos el childFragmentManagerque hace eso.
2. FragmentAes un fragmento padre de FragmentB, para acceder FragmentAdesde dentro FragmentBlo utilizaremos parenFragment.

Habiendo dicho eso, adentro 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")
    }
}

Aquí está el fragmento de diálogo 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")
    }
}

Aquí está la interfaz que une los dos.

interface UpdateNameListener {
    fun onSave(name: String)
}

Eso es.

Resolví esto de una manera elegante con RxAndroid. Reciba un observador en el constructor del DialogFragment y suscríbase a observable y empuje el valor cuando se llame la devolución de llamada. Luego, en su Fragmento, cree una clase interna del Observador, cree una instancia y pásela en el constructor del DialogFragment. Usé WeakReference en el observador para evitar pérdidas de memoria. Aquí está el código:

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

    }
}

Puede ver el código fuente aquí: https://github.com/andresuarezz26/carpoolingapp