Ricevi il risultato da DialogFragment

Sto usando DialogFragments per una serie di cose: scegliere l'elemento dalla lista, inserire il testo.

Qual è il modo migliore per restituire un valore (ovvero una stringa o un elemento da un elenco) all'attività / frammento chiamante?

Attualmente sto implementando l'attività di chiamata DismissListenere dando a DialogFragment un riferimento all'attività. La finestra di dialogo chiama quindi il OnDimissmetodo nell'attività e l'attività acquisisce il risultato dall'oggetto DialogFragment. Molto disordinato e non funziona sul cambio di configurazione (cambio di orientamento) in quanto DialogFragment perde il riferimento all'attività.

Grazie per qualsiasi aiuto.

Utilizzare myDialogFragment.setTargetFragment(this, MY_REQUEST_CODE)dal punto in cui viene mostrata la finestra di dialogo, quindi al termine della finestra di dialogo, da essa è possibile chiamare getTargetFragment().onActivityResult(getTargetRequestCode(), ...)e implementare onActivityResult()nel frammento contenente.

Sembra un abuso di onActivityResult(), soprattutto perché non coinvolge attività. Ma l'ho visto consigliato da google ufficiali e forse anche nelle demo di API. Penso che sia quello per cui g/setTargetFragment()sono stati aggiunti.

Come puoi vedere qui c'è un modo molto semplice per farlo.

Nel tuo DialogFragmentaggiungi un listener di interfaccia come:

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

Quindi, aggiungi un riferimento a quel listener:

private EditNameDialogListener listener;

Verrà utilizzato per "attivare" i metodi di ascolto e per verificare se l'attività / il frammento parent implementa questa interfaccia (vedere di seguito).

Nel Activity/ FragmentActivity/ Fragmentche "chiamato" ilDialogFragment semplicemente implementare questa interfaccia.

In DialogFragmenttutto ciò che devi aggiungere nel punto in cui desideri eliminare il DialogFragmente restituire il risultato è questo:

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

Dove si mEditText.getText().toString()trova ciò che verrà restituito alla chiamata Activity.

Nota che se vuoi restituire qualcos'altro, cambia semplicemente gli argomenti che l'ascoltatore accetta.

Infine, è necessario verificare se l'interfaccia è stata effettivamente implementata dall'attività / frammento padre:

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

Questa tecnica è molto flessibile e consente di richiamare con il risultato anche se non si desidera ancora chiudere la finestra di dialogo.

C'è un modo molto più semplice per ricevere un risultato da un DialogFragment.

Innanzitutto, in Attività, Frammento o FrammentoAttività è necessario aggiungere le seguenti informazioni:

@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.
         }
     }
}

L' requestCodeè fondamentalmente l'etichetta int per il DialogFragment hai chiamato, ti faccio vedere come funziona in un secondo. ResultCode è il codice che rispedisci da DialogFragment indicando cosa è successo all'attività di attesa, al frammento o all'attività del frammento in corso.

Il prossimo pezzo di codice da inserire è la chiamata a DialogFragment. Un esempio è qui:

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 queste tre righe stai dichiarando il tuo DialogFragment, impostando un requestCode (che chiamerà onActivityResult (...) una volta che il dialogo è stato chiuso, e poi stai mostrando la finestra di dialogo. È così semplice.

Ora, nel tuo DialogFragment devi solo aggiungere una riga direttamente prima di in dismiss()modo da inviare un resultCode a onActivityResult ().

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

Questo è tutto. Nota, il resultCode è definito come quello int resultCodeche ho impostato resultCode = 1;in questo caso.

Ecco fatto, ora puoi inviare il risultato del tuo DialogFragment all'attività chiamante, al frammento o all'attività del frammento.

Inoltre, sembra che queste informazioni siano state pubblicate in precedenza, ma non è stato fornito un esempio sufficiente, quindi ho pensato di fornire maggiori dettagli.

MODIFICA 24/06/2016 Mi scuso per il codice fuorviante di cui sopra. Ma sicuramente non puoi ricevere il risultato dall'attività visto come la linea:

dialogFrag.setTargetFragment(this, 1);

imposta un obiettivo Fragmente non Activity. Quindi per fare questo è necessario usare implement an InterfaceCommunicator.

Nel tuo DialogFragmentset una variabile globale

public InterfaceCommunicator interfaceCommunicator;

Crea una funzione pubblica per gestirla

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

Poi, quando si è pronti per inviare il codice di nuovo alla Activityquando l' DialogFragmentè fatto in esecuzione, è sufficiente aggiungere la linea prima di dismiss();tuo DialogFragment:

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

Nella tua attività ora devi fare due cose, la prima è rimuovere quella riga di codice che non è più applicabile:

dialogFrag.setTargetFragment(this, 1);  

Quindi implementa l'interfaccia e il gioco è fatto. Puoi farlo aggiungendo la seguente riga alla implementsclausola in cima alla tua classe:

public class MyClass Activity implements MyDialogFragment.InterfaceCommunicator

E poi @Overridela funzione nell'attività,

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

Si utilizza questo metodo di interfaccia proprio come si farebbe con il onActivityResult()metodo. Tranne il metodo di interfaccia è per DialogFragmentse l'altro è per Fragments.

Beh, è ​​troppo tardi per rispondere, ma ecco cosa ho fatto per ottenere risultati dal DialogFragment. molto simile alla risposta di @ brandon. Qui sto chiamando DialogFragmentda un frammento, basta inserire questo codice nel punto in cui stai chiamando la tua finestra di dialogo.

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

dov'è il categoryDialogmio DialogFragmentche voglio chiamare e dopo questo nella tua implementazione di dialogfragmentinserire questo codice in cui stai impostando i tuoi dati in modo mirato. Il valore di resultCodeè 1 è possibile impostarlo o utilizzare Definito dal sistema.

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

ora è il momento di tornare al frammento chiamante e implementare questo metodo. verificare la validità dei dati o il risultato positivo se si desidera con resultCodee requestCodein if condizione.

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

Approccio diverso, per consentire a un frammento di comunicare fino alla sua attività :

1) Definisci un'interfaccia pubblica nel frammento e creane una variabile

public OnFragmentInteractionListener mCallback;

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

2) Trasmetti l'attività alla variabile mCallback nel frammento

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

3) Implementa l'ascoltatore nella tua attività

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

4) Sovrascrivi OnFragmentInteraction nell'attività

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

Maggiori informazioni su di esso: https://developer.android.com/training/basics/fragments/communicating.html

Un modo semplice che ho trovato è stato il seguente: Implementa questo è il tuo dialogFragment,

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

E quindi nell'attività che ha chiamato il frammento della finestra di dialogo creare la funzione appropriata come tale:

 public void onUserSelectValue(String selectedValue) {

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

Il Toast è per dimostrare che funziona. Ha funzionato per me.

Sono molto sorpreso di vedere che nessuno ha suggerito di usare le trasmissioni locali per DialogFragmentper Activityla comunicazione! Trovo che sia molto più semplice e più pulito di altri suggerimenti. In sostanza, ti registri Activityaffinché ascolti le trasmissioni e invii le trasmissioni locali dalle tue DialogFragmentistanze. Semplice. Per una guida dettagliata su come impostare tutto, vedere qui .

O condividi ViewModel come mostrato qui:

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

Nel mio caso avevo bisogno di passare argomenti a targetFragment. Ma ho ricevuto l'eccezione "Frammento già attivo". Così ho dichiarato un'interfaccia nel mio DialogFragment implementata da parentFragment. Quando parentFragment ha avviato DialogFragment, si è impostato come TargetFragment. Quindi in DialogFragment ho chiamato

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

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

// La mia attività

class MyActivity: AppCompatActivity(),FiltroDialogFragment.InterfaceCommunicator {

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

Spero che serva, se puoi migliorare per favore modificalo. Il mio inglese non è molto buono

se si desidera inviare argomenti e ricevere il risultato dal secondo frammento, è possibile utilizzare Fragment.setArguments per eseguire questa attività

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 per averlo come una delle opzioni (dal momento che nessuno lo ha ancora menzionato) - potresti usare un bus per eventi come Otto. Quindi nella finestra di dialogo fai:

bus.post(new AnswerAvailableEvent(42));

E abbonati al chiamante (Attività o Frammento):

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