Communiquer entre un fragment et une activité-pratiques exemplaires

la méthode suggérée pour communiquer entre fragments est d'utiliser des callbacks\listeners qui sont gérés par votre activité principale.

je pense que le code sur cette page est assez clair: http://developer.android.com/training/basics/fragments/communicating.html

vous pouvez également faire référence à L'application Io 2012 Schedule, qui est conçue pour être une application de référence de facto. Il peut être trouvé ici: http://code.google.com/p/iosched /

aussi, Voici une question avec de bonnes informations: Comment transmettre des données entre fragments

il est mis en œuvre par call back interface: Tout d'abord, nous devons faire une interface:

public interface UpdateFrag {
     public void updatefrag();
    }

en activité do le code suivant:

UpdateFrag updatfrag ;
public void updateApi(UpdateFrag listener) {
        updatfrag = listener;
   }

de l'événement, d'où le rappel ont à feu dans l'activité:

updatfrag.updatefrag();

dans Fragment implémenter l'interface dans CreateView faire le code suivant:

 ((Home)getActivity()).updateApi(new UpdateFrag() {
                @Override
                public void updatefrag() {
                   .....your stuff......
                }
            });

j'ai fait une bibliothèque d'annotation qui peut faire le plâtre pour vous. check this out. https://github.com/zeroarst/callbackfragment /

@CallbackFragment
public class MyFragment extends Fragment {

    @Callback
    interface FragmentCallback {
       void onClickButton(MyFragment fragment);
    }    
    private FragmentCallback mCallback;

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.bt1
                mCallback.onClickButton(this);
                break;
            case R.id.bt2
                // Because we give mandatory = false so this might be null if not implemented by the host.
                if (mCallbackNotForce != null)
                mCallbackNotForce.onClickButton(this);
                break;
        }
    }
}

il génère alors une sous-classe de votre fragment. Et il suffit de l'ajouter à FragmentManager.

public class MainActivity extends AppCompatActivity implements MyFragment.FragmentCallback {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        getSupportFragmentManager().beginTransaction()
            .add(R.id.lo_fragm_container, MyFragmentCallbackable.create(), "MY_FRAGM")
            .commit();
    }

    Toast mToast;

    @Override
    public void onClickButton(MyFragment fragment) {
        if (mToast != null)
            mToast.cancel();
        mToast = Toast.makeText(this, "Callback from " + fragment.getTag(), Toast.LENGTH_SHORT);
        mToast.show();
    }
}

il y a plusieurs façons de communiquer entre activités, fragments, services, etc. Le plus évident est de communiquer en utilisant des interfaces. Cependant, ce n'est pas un moyen productif de communiquer. Vous devez implémenter les écouteurs, etc.

ma suggestion est d'utiliser un bus d'événement. Le bus d'événements est une implémentation de pattern publier/s'abonner.

vous pouvez vous abonner à des événements dans votre activité et ensuite vous pouvez poster ces événements dans vos fragments, etc.

Ici sur mon blog , vous pouvez trouver plus de détails sur ce modèle et aussi un exemple de projet pour montrer l'utilisation.

Je ne suis pas sûr que j'ai vraiment compris ce que vous voulez faire, mais la façon suggérée de communiquer entre les fragments est d'utiliser des callbacks avec l'activité, jamais directement entre les fragments. Voir ici http://developer.android.com/training/basics/fragments/communicating.html

pour communiquer entre un Activity et Fragment s, il y a plusieurs options, mais après beaucoup de lecture et de nombreuses expériences, j'ai découvert qu'il pourrait être repris de cette façon:

• Activity veut communiquer avec l'enfant Fragment = > simplement écrire des méthodes publiques dans votre classe Fragment , et laisser le Activity les appeler
• Fragment veut communiquer avec le parent Activity = > ceci nécessite un peu plus de travail, comme le lien officiel Android https://developer.android.com/training/basics/fragments/communicating suggère, ce serait une bonne idée de définir un interface qui sera mis en œuvre par le Activity , et qui établira un contrat pour tout Activity qui veut communiquer avec ce Fragment . Par exemple, si vous avez FragmentA , qui veut communiquer avec n'importe quel activity qui l'inclut, alors définir le FragmentAInterface qui définira quelle méthode peut le FragmentA appeler le activities qui décident de l'utiliser.
• Un Fragment veut communiquer avec les autres Fragment => C'est le cas où vous obtenez le plus "compliqué". Puisque vous pourriez avoir besoin de passer des données de FragmentA à FragmentB et viceversa, cela pourrait nous conduire à définir 2 interfaces, FragmentAInterface qui sera mis en œuvre par FragmentB et FragmentAInterface qui sera mis en œuvre par FragmentA . Ça va commencer à rendre les choses difficiles. Et imaginez si vous avez un peu plus Fragment s sur place, et même le parent activity veut communiquer avec eux. Eh bien, cette affaire est un moment parfait pour établir un ViewModel partagé pour le activity et il est fragment S. Plus d'informations ici https://developer.android.com/topic/libraries/architecture/viewmodel . Fondamentalement, vous devez définir une classe SharedViewModel , qui a toutes les données que vous voulez partager entre le activity et le fragments qui auront besoin de communiquer des données entre eux.

l'affaire ViewModel , rend les choses plus simples à la fin, puisque vous n'avez pas à ajouter de logique supplémentaire qui rend les choses sales dans le code et salissant. De Plus, il vous permettra de séparer la collecte (au moyen d'appels vers une base de données SQLite ou une API) des données du Controller ( activities et fragments ).

vous pouvez créer déclarer une interface publique avec une déclaration de fonction dans le fragment et mettre en œuvre l'interface dans l'activité. Ensuite, vous pouvez appeler la fonction à partir du fragment.

j'utilise Intents pour communiquer les actions de retour à l'activité principale. L'activité principale consiste à les écouter en les surpassant de nouveau(intention). L'activité principale traduit ces actions en fragments correspondants par exemple.

donc vous pouvez faire quelque chose comme ça:

public class MainActivity extends Activity  {

    public static final String INTENT_ACTION_SHOW_FOO = "show_foo";
    public static final String INTENT_ACTION_SHOW_BAR = "show_bar";


   @Override
   protected void onNewIntent(Intent intent) {
        routeIntent(intent);
   }

  private void routeIntent(Intent intent) {
       String action = intent.getAction();
       if (action != null) {               
            switch (action) {
            case INTENT_ACTION_SHOW_FOO:
                // for example show the corresponding fragment
                loadFragment(FooFragment);
                break;
            case INTENT_ACTION_SHOW_BAR:
                loadFragment(BarFragment);
                break;               
        }
    }
}

puis dans n'importe quel fragment pour montrer le fragment de foo:

Intent intent = new Intent(context, MainActivity.class);
intent.setAction(INTENT_ACTION_SHOW_FOO);
// Prevent activity to be re-instantiated if it is already running.
// Instead, the onNewEvent() is triggered
intent.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP | Intent.FLAG_ACTIVITY_CLEAR_TOP);
getContext().startActivity(intent);