Recibir resultado de DialogFragment

Estoy usando DialogFragments para varias cosas: elegir un elemento de la lista, ingresar texto.

¿Cuál es la mejor manera de devolver un valor (es decir, una cadena o un elemento de una lista) a la actividad / fragmento de llamada?

Actualmente estoy implementando la actividad de llamadas DismissListenery le estoy dando al DialogFragment una referencia a la actividad. Luego, OnDimissel cuadro de diálogo llama al método en la actividad y la actividad toma el resultado del objeto DialogFragment. Muy desordenado y no funciona en el cambio de configuración (cambio de orientación) ya que DialogFragment pierde la referencia a la actividad.

Gracias por cualquier ayuda.

Úselo myDialogFragment.setTargetFragment(this, MY_REQUEST_CODE)desde el lugar donde muestra el cuadro de diálogo, y luego cuando termine su cuadro de diálogo, desde allí puede llamar getTargetFragment().onActivityResult(getTargetRequestCode(), ...)e implementar onActivityResult()en el fragmento que lo contiene.

Parece un abuso de onActivityResult(), especialmente porque no involucra actividades en absoluto. Pero lo he visto recomendado por la gente oficial de Google, y tal vez incluso en las demostraciones de la API. Creo que es para lo que g/setTargetFragment()se agregaron.

Como puede ver aquí, hay una manera muy simple de hacerlo.

En su DialogFragmentagregar un oyente de interfaz como:

public interface EditNameDialogListener {
    void onFinishEditDialog(String inputText);
}

Luego, agregue una referencia a ese oyente:

private EditNameDialogListener listener;

Esto se usará para "activar" los métodos de escucha, y también para verificar si la Actividad / Fragmento principal implementa esta interfaz (ver más abajo).

En el Activity/ FragmentActivity/ Fragmentque "llamó" DialogFragmentsimplemente implementan esta interfaz.

En DialogFragmenttodo lo que necesita agregar en el punto donde desea descartar DialogFragmenty devolver el resultado es este:

listener.onFinishEditDialog(mEditText.getText().toString());
this.dismiss();

¿Dónde mEditText.getText().toString()está lo que se pasará de nuevo a la llamada Activity?

Tenga en cuenta que si desea devolver algo más, simplemente cambie los argumentos que toma el oyente.

Finalmente, debe verificar si la interfaz fue implementada realmente por la actividad / fragmento principal:

@Override
public void onAttach(Context context) {
    super.onAttach(context);
    // Verify that the host activity implements the callback interface
    try {
        // Instantiate the EditNameDialogListener so we can send events to the host
        listener = (EditNameDialogListener) context;
    } catch (ClassCastException e) {
        // The activity doesn't implement the interface, throw exception
        throw new ClassCastException(context.toString()
                + " must implement EditNameDialogListener");
    }
}

Esta técnica es muy flexible y permite volver a llamar con el resultado incluso si aún no desea cerrar el diálogo.

Hay una forma mucho más simple de recibir un resultado de un DialogFragment.

Primero, en su Actividad, Fragmento o Fragmento de Actividad, necesita agregar la siguiente información:

@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
    // Stuff to do, dependent on requestCode and resultCode
    if(requestCode == 1) { // 1 is an arbitrary number, can be any int
         // This is the return result of your DialogFragment
         if(resultCode == 1) { // 1 is an arbitrary number, can be any int
              // Now do what you need to do after the dialog dismisses.
         }
     }
}

El requestCodees básicamente la etiqueta int para el DialogFragment que llama, voy a mostrar cómo funciona esto en un segundo. ResultCode es el código que envía de regreso desde el DialogFragment que le dice a su Actividad, Fragmento o FragmentoActividad actual en espera lo que sucedió.

El siguiente fragmento de código que debe ingresar es la llamada al DialogFragment. Un ejemplo está aquí:

DialogFragment dialogFrag = new MyDialogFragment();
// This is the requestCode that you are sending.
dialogFrag.setTargetFragment(this, 1);     
// This is the tag, "dialog" being sent.
dialogFrag.show(getFragmentManager(), "dialog");

Con estas tres líneas está declarando su DialogFragment, configurando un requestCode (que llamará a onActivityResult (...) una vez que se descarta el Diálogo, y luego está mostrando el diálogo. Es así de simple.

Ahora, en su DialogFragment solo necesita agregar una línea directamente antes de la dismiss()para que pueda enviar un resultCode de nuevo a onActivityResult ().

getTargetFragment().onActivityResult(getTargetRequestCode(), resultCode, getActivity().getIntent());
dismiss();

Eso es. Tenga en cuenta que el resultCode se define como el int resultCodeque he establecido resultCode = 1;en este caso.

Eso es todo, ahora puede enviar el resultado de su DialogFragment a su Actividad de llamada, Fragmento o FragmentActivity.

Además, parece que esta información se publicó anteriormente, pero no hubo un ejemplo suficiente dado, así que pensé en proporcionar más detalles.

EDITAR 06.24.2016 Pido disculpas por el código engañoso anterior. Pero ciertamente no puede recibir el resultado de vuelta a la actividad como la línea:

dialogFrag.setTargetFragment(this, 1);

establece un objetivo Fragmenty no Activity. Entonces, para hacer esto, debe usar Implementar un InterfaceCommunicator.

En su DialogFragmentconjunto una variable global

public InterfaceCommunicator interfaceCommunicator;

Crear una función pública para manejarlo

public interface InterfaceCommunicator {
    void sendRequestCode(int code);
}

Luego, cuando esté listo para enviar el código de nuevo Activitycuando DialogFragmenttermine de ejecutarse, simplemente agregue la línea antes de dismiss();su DialogFragment:

interfaceCommunicator.sendRequestCode(1); // the parameter is any int code you choose.

En su actividad ahora tiene que hacer dos cosas, la primera es eliminar esa línea de código que ya no es aplicable:

dialogFrag.setTargetFragment(this, 1);  

Luego implemente la interfaz y ya está. Puede hacerlo agregando la siguiente línea a la implementscláusula en la parte superior de su clase:

public class MyClass Activity implements MyDialogFragment.InterfaceCommunicator

Y luego @Overridela función en la actividad,

@Override
public void sendRequestCode(int code) {
    // your code here
}

Utiliza este método de interfaz como lo haría con el onActivityResult()método. Excepto que el método de interfaz es para DialogFragmentsy el otro es para Fragments.

Bueno, es demasiado tarde para responder, pero esto es lo que hice para obtener resultados del DialogFragment. muy similar a la respuesta de @ brandon. Aquí estoy llamando DialogFragmentdesde un fragmento, simplemente coloque este código donde está llamando a su diálogo.

FragmentManager fragmentManager = getFragmentManager();
            categoryDialog.setTargetFragment(this,1);
            categoryDialog.show(fragmentManager, "dialog");

donde categoryDialoges mi al DialogFragmentque quiero llamar y después de esto en su implementación de dialogfragmentcolocar este código donde está configurando sus datos intencionalmente. El valor de resultCodees 1 puede configurarlo o usar Definido por sistema.

            Intent intent = new Intent();
            intent.putExtra("listdata", stringData);
            getTargetFragment().onActivityResult(getTargetRequestCode(), resultCode, intent);
            getDialog().dismiss();

ahora es el momento de volver al fragmento de llamada e implementar este método. comprobar la validez de los datos o dar como resultado el éxito si se desea con resultCodey requestCodeen caso de condiciones.

 @Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);        
        //do what ever you want here, and get the result from intent like below
        String myData = data.getStringExtra("listdata");
Toast.makeText(getActivity(),data.getStringExtra("listdata"),Toast.LENGTH_SHORT).show();
    }

Enfoque diferente, para permitir que un Fragment se comunique con su Actividad :

1) Defina una interfaz pública en el fragmento y cree una variable para él

public OnFragmentInteractionListener mCallback;

public interface OnFragmentInteractionListener {
    void onFragmentInteraction(int id);
}

2) Transmita la actividad a la variable mCallback en el fragmento

try {
    mCallback = (OnFragmentInteractionListener) getActivity();
} catch (Exception e) {
    Log.d(TAG, e.getMessage());
}

3) Implemente al oyente en su actividad

public class MainActivity extends AppCompatActivity implements DFragment.OnFragmentInteractionListener  {
     //your code here
}

4) Anular OnFragmentInteraction en la actividad

@Override
public void onFragmentInteraction(int id) {
    Log.d(TAG, "received from fragment: " + id);
}

Más información al respecto: https://developer.android.com/training/basics/fragments/communicating.html

Una forma fácil que encontré fue la siguiente: Implemente este es su cuadro de diálogo Fragmento,

  CallingActivity callingActivity = (CallingActivity) getActivity();
  callingActivity.onUserSelectValue("insert selected value here");
  dismiss();

Y luego, en la actividad que llamó al Fragmento de Diálogo, cree la función apropiada como tal:

 public void onUserSelectValue(String selectedValue) {

        // TODO add your implementation.
      Toast.makeText(getBaseContext(), ""+ selectedValue, Toast.LENGTH_LONG).show();
    }

El brindis es para demostrar que funciona. Trabajó para mi.

Estoy muy sorprendido al ver que nadie ha sugerido el uso de transmisiones locales para DialogFragmentque Activityla comunicación! Me parece mucho más simple y limpio que otras sugerencias. Esencialmente, se registra para Activityescuchar las transmisiones y envía las transmisiones locales desde sus DialogFragmentinstancias. Sencillo. Para obtener una guía paso a paso sobre cómo configurarlo todo, consulte aquí .

O comparta ViewModel como se muestra aquí:

public class SharedViewModel extends ViewModel {
    private final MutableLiveData<Item> selected = new MutableLiveData<Item>();

    public void select(Item item) {
        selected.setValue(item);
    }

    public LiveData<Item> getSelected() {
        return selected;
    }
}


public class MasterFragment extends Fragment {
    private SharedViewModel model;
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        model = ViewModelProviders.of(getActivity()).get(SharedViewModel.class);
        itemSelector.setOnClickListener(item -> {
            model.select(item);
        });
    }
}

public class DetailFragment extends Fragment {
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        SharedViewModel model = ViewModelProviders.of(getActivity()).get(SharedViewModel.class);
        model.getSelected().observe(this, { item ->
           // Update the UI.
        });
    }
}

https://developer.android.com/topic/libraries/architecture/viewmodel#sharing_data_between_fragments

En mi caso, necesitaba pasar argumentos a un targetFragment. Pero obtuve la excepción "Fragmento ya activo". Así que declaró una interfaz en mi DialogFragment que parentFragment implementó. Cuando parentFragment inició un DialogFragment, se estableció como TargetFragment. Luego en DialogFragment llamé

 ((Interface)getTargetFragment()).onSomething(selectedListPosition);

En kotlin

    // My DialogFragment
class FiltroDialogFragment : DialogFragment(), View.OnClickListener {
    
    var listener: InterfaceCommunicator? = null

    override fun onAttach(context: Context?) {
        super.onAttach(context)
        listener = context as InterfaceCommunicator
    }

    interface InterfaceCommunicator {
        fun sendRequest(value: String)
    }   

    override fun onClick(v: View) {
        when (v.id) {
            R.id.buttonOk -> {    
        //You can change value             
                listener?.sendRequest('send data')
                dismiss()
            }
            
        }
    }
}

// Mi actividad

class MyActivity: AppCompatActivity(),FiltroDialogFragment.InterfaceCommunicator {

    override fun sendRequest(value: String) {
    // :)
    Toast.makeText(this, value, Toast.LENGTH_LONG).show()
    }
}
 

Espero que sirva, si puede mejorar, edítelo. Mi Inglés no es muy bueno

si desea enviar argumentos y recibir el resultado del segundo fragmento, puede usar Fragment.setArguments para realizar esta tarea

static class FirstFragment extends Fragment {
    final Handler mUIHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
            case 101: // receive the result from SecondFragment
                Object result = msg.obj;
                // do something according to the result
                break;
            }
        };
    };

    void onStartSecondFragments() {
        Message msg = Message.obtain(mUIHandler, 101, 102, 103, new Object()); // replace Object with a Parcelable if you want to across Save/Restore
                                                                               // instance
        putParcelable(new SecondFragment(), msg).show(getFragmentManager().beginTransaction(), null);
    }
}

static class SecondFragment extends DialogFragment {
    Message mMsg; // arguments from the caller/FirstFragment

    @Override
    public void onViewCreated(View view, Bundle savedInstanceState) {
        // TODO Auto-generated method stub
        super.onViewCreated(view, savedInstanceState);
        mMsg = getParcelable(this);
    }

    void onClickOK() {
        mMsg.obj = new Object(); // send the result to the caller/FirstFragment
        mMsg.sendToTarget();
    }
}

static <T extends Fragment> T putParcelable(T f, Parcelable arg) {
    if (f.getArguments() == null) {
        f.setArguments(new Bundle());
    }
    f.getArguments().putParcelable("extra_args", arg);
    return f;
}
static <T extends Parcelable> T getParcelable(Fragment f) {
    return f.getArguments().getParcelable("extra_args");
}

Solo para tenerlo como una de las opciones (ya que nadie lo mencionó aún): puede usar un autobús de eventos como Otto. Entonces en el diálogo que haces:

bus.post(new AnswerAvailableEvent(42));

Y haga que su interlocutor (Actividad o Fragmento) se suscriba:

@Subscribe public void answerAvailable(AnswerAvailableEvent event) {
   // TODO: React to the event somehow!
}