Recevoir le résultat de DialogFragment

J'utilise DialogFragments pour un certain nombre de choses: choisir un élément dans la liste, saisir du texte.

Quelle est la meilleure façon de renvoyer une valeur (c'est-à-dire une chaîne ou un élément d'une liste) à l'activité / au fragment appelant?

Actuellement, je fais implémenter l'activité d'appel DismissListeneret donne au DialogFragment une référence à l'activité. La boîte de dialogue appelle ensuite la OnDimissméthode dans l'activité et l'activité récupère le résultat de l'objet DialogFragment. Très désordonné et cela ne fonctionne pas sur le changement de configuration (changement d'orientation) car DialogFragment perd la référence à l'activité.

Merci pour toute aide.

Utilisez à myDialogFragment.setTargetFragment(this, MY_REQUEST_CODE)partir de l'endroit où vous affichez la boîte de dialogue, puis lorsque votre boîte de dialogue est terminée, vous pouvez l'appeler getTargetFragment().onActivityResult(getTargetRequestCode(), ...)et l'implémenter onActivityResult()dans le fragment contenant.

Cela semble être un abus onActivityResult(), d'autant plus qu'il n'implique aucune activité. Mais je l'ai vu recommandé par les responsables officiels de Google, et peut-être même dans les démos de l'API. Je pense que c'est ce qui a g/setTargetFragment()été ajouté.

Comme vous pouvez le voir ici, il existe un moyen très simple de le faire.

Dans votre DialogFragmentajouter un écouteur d'interface comme:

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

Ensuite, ajoutez une référence à cet écouteur:

private EditNameDialogListener listener;

Cela sera utilisé pour "activer" la ou les méthodes d'écoute, et également pour vérifier si l'activité / le fragment parent implémente cette interface (voir ci-dessous).

Dans le Activity/ FragmentActivity/Fragment qui "appelé", DialogFragmentimplémentez simplement cette interface.

Dans votre DialogFragmenttout, vous devez ajouter au point où vous souhaitez supprimer le DialogFragmentet renvoyer le résultat est le suivant:

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

Où mEditText.getText().toString()est ce qui sera renvoyé à l'appel Activity.

Notez que si vous souhaitez renvoyer autre chose, changez simplement les arguments pris par l'auditeur.

Enfin, vous devez vérifier si l'interface a été réellement implémentée par l'activité / le fragment parent:

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

Cette technique est très flexible et permet de rappeler le résultat même si vous ne souhaitez pas fermer la boîte de dialogue pour l'instant.

Il existe un moyen beaucoup plus simple de recevoir un résultat d'un DialogFragment.

Tout d'abord, dans votre activité, fragment ou activité de fragment, vous devez ajouter les informations suivantes:

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

C'est requestCodefondamentalement votre étiquette int pour le DialogFragment que vous avez appelé, je vais montrer comment cela fonctionne dans une seconde. Le resultCode est le code que vous renvoyez du DialogFragment indiquant à votre Activity, Fragment ou FragmentActivity en attente ce qui s'est passé.

Le morceau de code suivant à entrer est l'appel au DialogFragment. Un exemple est ici:

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

Avec ces trois lignes, vous déclarez votre DialogFragment, définissez un requestCode (qui appellera onActivityResult (...) une fois la boîte de dialogue fermée et vous affichez ensuite la boîte de dialogue. C'est aussi simple que cela.

Maintenant, dans votre DialogFragment, vous devez simplement ajouter une ligne juste avant le dismiss()afin de renvoyer un resultCode au onActivityResult ().

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

C'est tout. Remarque, le resultCode est défini comme int resultCodecelui que j'ai défini resultCode = 1;dans ce cas.

Voilà, vous pouvez maintenant renvoyer le résultat de votre DialogFragment à votre activité d'appel, fragment ou activité de fragment.

De plus, il semble que ces informations aient été publiées précédemment, mais aucun exemple suffisant n'a été donné, j'ai donc pensé fournir plus de détails.

EDIT 06.24.2016 Je m'excuse pour le code trompeur ci-dessus. Mais vous ne pouvez certainement pas recevoir le résultat de l'activité en tant que ligne:

dialogFrag.setTargetFragment(this, 1);

fixe un objectif Fragmentet non Activity. Donc, pour ce faire, vous devez utiliser implémenter un InterfaceCommunicator.

Dans votre DialogFragmentensemble une variable globale

public InterfaceCommunicator interfaceCommunicator;

Créer une fonction publique pour la gérer

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

Ensuite , lorsque vous êtes prêt à envoyer le dos de code à Activityquand l' DialogFragmentest fait en cours d' exécution, vous ajoutez simplement la ligne avant dismiss();votre DialogFragment:

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

Dans votre activité, vous devez maintenant faire deux choses, la première consiste à supprimer cette seule ligne de code qui n'est plus applicable:

dialogFrag.setTargetFragment(this, 1);  

Ensuite, implémentez l'interface et vous avez terminé. Vous pouvez le faire en ajoutant la ligne suivante à la implementsclause tout en haut de votre classe:

public class MyClass Activity implements MyDialogFragment.InterfaceCommunicator

Et puis @Overridela fonction dans l'activité,

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

Vous utilisez cette méthode d'interface comme vous le feriez pour la onActivityResult()méthode. Sauf que la méthode d'interface est pour DialogFragmentset l'autre est pour Fragments.

Il est peut-être trop tard pour répondre, mais voici ce que j'ai fait pour obtenir des résultats de la DialogFragment. très similaire à la réponse de @ brandon. Ici, j'appelle à DialogFragmentpartir d'un fragment, placez simplement ce code là où vous appelez votre boîte de dialogue.

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

où categoryDialogest mon DialogFragmentque je veux appeler et après cela dans votre implémentation de dialogfragmentplacer ce code où vous définissez vos données dans l'intention. La valeur de resultCodeest 1, vous pouvez la définir ou utiliser Défini par le système.

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

il est maintenant temps de revenir au fragment appelant et d'implémenter cette méthode. vérifiez la validité des données ou la réussite des résultats si vous le souhaitez avec resultCodeet requestCodedans la condition if.

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

Approche différente, pour permettre à un Fragment de communiquer jusqu'à son Activité :

1) Définissez une interface publique dans le fragment et créez une variable pour celle-ci

public OnFragmentInteractionListener mCallback;

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

2) Cast l'activité sur la variable mCallback dans le fragment

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

3) Implémentez l'auditeur dans votre activité

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

4) Remplacer l'interaction OnFragment dans l'activité

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

Plus d'informations à ce sujet: https://developer.android.com/training/basics/fragments/communicating.html

Un moyen simple que j'ai trouvé était le suivant: implémentez ceci est votre dialogFragment,

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

Et puis, dans l'activité qui a appelé le fragment de dialogue, créez la fonction appropriée en tant que telle:

 public void onUserSelectValue(String selectedValue) {

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

Le Toast est de montrer que cela fonctionne. A travaillé pour moi.

Je suis très surpris de voir que personne ne l'a suggéré d' utiliser des émissions locales pour DialogFragmentla Activitycommunication! Je trouve que c'est tellement plus simple et plus propre que les autres suggestions. Essentiellement, vous vous inscrivez pour Activityécouter les émissions et vous envoyez les émissions locales à partir de vos DialogFragmentinstances. Facile. Pour un guide étape par étape sur la façon de tout configurer, voir ici .

Ou partagez ViewModel comme montré ici:

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

Dans mon cas, j'avais besoin de passer des arguments à un targetFragment. Mais j'ai eu l'exception "Fragment déjà actif". J'ai donc déclaré une interface dans mon DialogFragment que parentFragment a implémenté. Lorsque parentFragment a démarré un DialogFragment, il s'est défini comme TargetFragment. Puis dans DialogFragment j'ai appelé

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

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

// Mon activité

class MyActivity: AppCompatActivity(),FiltroDialogFragment.InterfaceCommunicator {

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

J'espère que cela sert, si vous pouvez l'améliorer, veuillez le modifier. Mon anglais n'est pas très bon

si vous souhaitez envoyer des arguments et recevoir le résultat du deuxième fragment, vous pouvez utiliser Fragment.setArguments pour accomplir cette tâche

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

Juste pour l'avoir comme l'une des options (puisque personne ne l'a encore mentionné) - vous pouvez utiliser un bus d'événements comme Otto. Donc, dans la boîte de dialogue, vous faites:

bus.post(new AnswerAvailableEvent(42));

Et demandez à votre correspondant (Activité ou Fragment) de s'y abonner:

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