Communiquer avec des fragments

Pour réutiliser des fragments, créez-les en tant que composants entièrement autonomes définissant leur propre mise en page et leur propre comportement. Une fois que vous avez défini ces fragments réutilisables, vous pouvez les associer à une activité et les connecter à la logique d'application pour créer l'interface utilisateur globale.

Pour réagir correctement aux événements utilisateur et partager des informations d'état, des canaux de communication entre une activité et ses fragments, ou entre deux fragments ou plus, sont souvent nécessaires. Pour que les fragments restent autonomes, ils ne doivent pas communiquer directement avec les autres fragments ni avec leur activité hôte.

La bibliothèque Fragment fournit deux options de communication : un ViewModel partagé et l'API Fragment Result. L'option recommandée dépend du cas d'utilisation. Pour partager des données persistantes avec des API personnalisées, utilisez un ViewModel. Pour obtenir un résultat unique comportant des données pouvant être placées dans un Bundle, utilisez l'API Fragment Result.

Les sections suivantes expliquent comment utiliser ViewModel et l'API Fragment Result pour communiquer entre vos fragments et vos activités.

Partager des données à l'aide d'un ViewModel

ViewModel est un choix idéal lorsque vous devez partager des données entre plusieurs fragments ou entre des fragments et leur activité hôte. Les objets ViewModel stockent et gèrent les données d'interface utilisateur. Pour en savoir plus sur ViewModel, consultez la section Présentation de ViewModel.

Partager des données avec l'activité de l'hôte

Dans certains cas, vous devrez peut-être partager des données entre les fragments et leur activité hôte. Imaginons que vous souhaitiez activer ou désactiver un composant d'interface utilisateur global en fonction d'une interaction au sein d'un fragment.

Examinez l'élément ItemViewModel suivant :

class ItemViewModel : ViewModel() {
    private val mutableSelectedItem = MutableLiveData<Item>()
    val selectedItem: LiveData<Item> get() = mutableSelectedItem

    fun selectItem(item: Item) {
        mutableSelectedItem.value = item
    }
}

public class ItemViewModel extends ViewModel {
    private final MutableLiveData<Item> selectedItem = new MutableLiveData<Item>();
    public void selectItem(Item item) {
        selectedItem.setValue(item);
    }
    public LiveData<Item> getSelectedItem() {
        return selectedItem;
    }
}

Dans cet exemple, les données stockées sont encapsulées dans une classe MutableLiveData. LiveData est une classe de conteneur de données observable compatible avec le cycle de vie. MutableLiveData permet la modification de sa valeur. Pour en savoir plus sur LiveData, consultez la présentation de LiveData.

Votre fragment et son activité hôte peuvent récupérer une instance partagée d'un ViewModel avec un champ d'application d'activité en transmettant l'activité au constructeur ViewModelProvider. ViewModelProvider gère l'instanciation de ViewModel ou sa récupération s'il existe déjà. Les deux composants peuvent observer et modifier ces données.

class MainActivity : AppCompatActivity() {
    // Using the viewModels() Kotlin property delegate from the activity-ktx
    // artifact to retrieve the ViewModel in the activity scope.
    private val viewModel: ItemViewModel by viewModels()
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        viewModel.selectedItem.observe(this, Observer { item ->
            // Perform an action with the latest item data.
        })
    }
}

class ListFragment : Fragment() {
    // Using the activityViewModels() Kotlin property delegate from the
    // fragment-ktx artifact to retrieve the ViewModel in the activity scope.
    private val viewModel: ItemViewModel by activityViewModels()

    // Called when the item is clicked.
    fun onItemClicked(item: Item) {
        // Set a new item.
        viewModel.selectItem(item)
    }
}

public class MainActivity extends AppCompatActivity {
    private ItemViewModel viewModel;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        viewModel = new ViewModelProvider(this).get(ItemViewModel.class);
        viewModel.getSelectedItem().observe(this, item -> {
            // Perform an action with the latest item data.
        });
    }
}

public class ListFragment extends Fragment {
    private ItemViewModel viewModel;

    @Override
    public void onViewCreated(@NonNull View view, Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        viewModel = new ViewModelProvider(requireActivity()).get(ItemViewModel.class);
        ...
        items.setOnClickListener(item -> {
            // Set a new item.
            viewModel.select(item);
        });
    }
}

Partager des données entre fragments

Deux fragments d'une même activité ou plus doivent souvent communiquer entre eux. Imaginez, par exemple, un fragment qui affiche une liste et un autre permettant à l'utilisateur d'appliquer divers filtres à cette liste. La mise en œuvre de ce scénario n'est pas simple si les fragments ne communiquent pas directement, auquel cas ils ne seront plus autonomes. En outre, les deux fragments doivent gérer le scénario dans lequel l'autre fragment n'est pas encore créé ni visible.

Ces fragments peuvent partager un ViewModel avec le champ d'application de leur activité pour gérer cette communication. En partageant le ViewModel de cette manière, les fragments n'ont pas besoin de se connaître, et l'activité n'a rien à faire pour permettre la communication.

L'exemple suivant montre comment deux fragments peuvent communiquer à l'aide d'un ViewModel partagé :

class ListViewModel : ViewModel() {
    val filters = MutableLiveData<Set<Filter>>()

    private val originalList: LiveData<List<Item>>() = ...
    val filteredList: LiveData<List<Item>> = ...

    fun addFilter(filter: Filter) { ... }

    fun removeFilter(filter: Filter) { ... }
}

class ListFragment : Fragment() {
    // Using the activityViewModels() Kotlin property delegate from the
    // fragment-ktx artifact to retrieve the ViewModel in the activity scope.
    private val viewModel: ListViewModel by activityViewModels()
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        viewModel.filteredList.observe(viewLifecycleOwner, Observer { list ->
            // Update the list UI.
        }
    }
}

class FilterFragment : Fragment() {
    private val viewModel: ListViewModel by activityViewModels()
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        viewModel.filters.observe(viewLifecycleOwner, Observer { set ->
            // Update the selected filters UI.
        }
    }

    fun onFilterSelected(filter: Filter) = viewModel.addFilter(filter)

    fun onFilterDeselected(filter: Filter) = viewModel.removeFilter(filter)
}

public class ListViewModel extends ViewModel {
    private final MutableLiveData<Set<Filter>> filters = new MutableLiveData<>();

    private final LiveData<List<Item>> originalList = ...;
    private final LiveData<List<Item>> filteredList = ...;

    public LiveData<List<Item>> getFilteredList() {
        return filteredList;
    }

    public LiveData<Set<Filter>> getFilters() {
        return filters;
    }

    public void addFilter(Filter filter) { ... }

    public void removeFilter(Filter filter) { ... }
}

public class ListFragment extends Fragment {
    private ListViewModel viewModel;

    @Override
    public void onViewCreated(@NonNull View view, Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        viewModel = new ViewModelProvider(requireActivity()).get(ListViewModel.class);
        viewModel.getFilteredList().observe(getViewLifecycleOwner(), list -> {
            // Update the list UI.
        });
    }
}

public class FilterFragment extends Fragment {
    private ListViewModel viewModel;

    @Override
    public void onViewCreated(@NonNull View view, Bundle savedInstanceState) {
        viewModel = new ViewModelProvider(requireActivity()).get(ListViewModel.class);
        viewModel.getFilters().observe(getViewLifecycleOwner(), set -> {
            // Update the selected filters UI.
        });
    }

    public void onFilterSelected(Filter filter) {
        viewModel.addFilter(filter);
    }

    public void onFilterDeselected(Filter filter) {
        viewModel.removeFilter(filter);
    }
}

Les deux fragments utilisent leur activité hôte comme champ d'application pour ViewModelProvider. Comme les fragments reposent sur le même champ d'application, ils reçoivent la même instance de ViewModel, ce qui leur permet de communiquer entre eux.

Partager des données entre un fragment parent et un fragment enfant

Lorsque vous utilisez des fragments enfants, le fragment parent et ses fragments enfants peuvent avoir besoin de partager des données les uns avec les autres. Pour partager des données entre ces fragments, utilisez le fragment parent en tant que champ d'application du fichier ViewModel, comme illustré dans l'exemple suivant :

class ListFragment: Fragment() {
    // Using the viewModels() Kotlin property delegate from the fragment-ktx
    // artifact to retrieve the ViewModel.
    private val viewModel: ListViewModel by viewModels()
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        viewModel.filteredList.observe(viewLifecycleOwner, Observer { list ->
            // Update the list UI.
        }
    }
}

class ChildFragment: Fragment() {
    // Using the viewModels() Kotlin property delegate from the fragment-ktx
    // artifact to retrieve the ViewModel using the parent fragment's scope
    private val viewModel: ListViewModel by viewModels({requireParentFragment()})
    ...
}

public class ListFragment extends Fragment {
    private ListViewModel viewModel;

    @Override
    public void onViewCreated(@NonNull View view, Bundle savedInstanceState) {
        viewModel = new ViewModelProvider(this).get(ListViewModel.class);
        viewModel.getFilteredList().observe(getViewLifecycleOwner(), list -> {
            // Update the list UI.
        }
    }
}

public class ChildFragment extends Fragment {
    private ListViewModel viewModel;
    @Override
    public void onViewCreated(@NonNull View view, Bundle savedInstanceState) {
        viewModel = new ViewModelProvider(requireParentFragment()).get(ListViewModel.class);
        ...
    }
}

Appliquer un ViewModel au graphique de navigation

Si vous utilisez la bibliothèque de navigation, vous pouvez également appliquer un ViewModel au cycle de vie de l'élément NavBackStackEntry d'une destination. Par exemple, le champ d'application du ViewModel peut être limité à l'élément NavBackStackEntry de ListFragment :

class ListFragment: Fragment() {
    // Using the navGraphViewModels() Kotlin property delegate from the fragment-ktx
    // artifact to retrieve the ViewModel using the NavBackStackEntry scope.
    // R.id.list_fragment == the destination id of the ListFragment destination
    private val viewModel: ListViewModel by navGraphViewModels(R.id.list_fragment)

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        viewModel.filteredList.observe(viewLifecycleOwner, Observer { item ->
            // Update the list UI.
        }
    }
}

public class ListFragment extends Fragment {
    private ListViewModel viewModel;

    @Override
    public void onViewCreated(@NonNull View view, Bundle savedInstanceState) {
    NavController navController = NavHostFragment.findNavController(this);
        NavBackStackEntry backStackEntry = navController.getBackStackEntry(R.id.list_fragment)

        viewModel = new ViewModelProvider(backStackEntry).get(ListViewModel.class);
        viewModel.getFilteredList().observe(getViewLifecycleOwner(), list -> {
            // Update the list UI.
        }
    }
}

Pour en savoir plus sur l'application d'un champ d'application ViewModel à un élément NavBackStackEntry, consultez la section Interagir de façon programmatique avec le composant Navigation.

Obtenir des résultats à l'aide de l'API Fragment Result

Dans certains cas, vous pouvez transmettre une valeur ponctuelle entre deux fragments ou entre un fragment et son activité hôte. Par exemple, vous pouvez avoir un fragment qui lit des codes QR en transmettant les données à un fragment précédent.

Dans les versions 1.3.0 et ultérieures de l'API Fragment, chaque FragmentManager implémente FragmentResultOwner. Autrement dit, un FragmentManager peut agir en tant que stockage central pour les résultats de fragment. Cette modification permet aux composants de communiquer entre eux en définissant des résultats de fragment et en écoutant ces résultats sans que ces composants ne renvoient directement les uns aux autres.

Transmettre des résultats entre fragments

Pour renvoyer des données au fragment A à partir du fragment B, commencez par définir un écouteur de résultats au niveau du fragment A (fragment qui recevra le résultat). Appelez setFragmentResultListener() au niveau de la fonction FragmentManager du fragment A, comme illustré dans l'exemple suivant :

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    // Use the Kotlin extension in the fragment-ktx artifact.
    setFragmentResultListener("requestKey") { requestKey, bundle ->
        // We use a String here, but any type that can be put in a Bundle is supported.
        val result = bundle.getString("bundleKey")
        // Do something with the result.
    }
}

@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    getParentFragmentManager().setFragmentResultListener("requestKey", this, new FragmentResultListener() {
        @Override
        public void onFragmentResult(@NonNull String requestKey, @NonNull Bundle bundle) {
            // We use a String here, but any type that can be put in a Bundle is supported.
            String result = bundle.getString("bundleKey");
            // Do something with the result.
        }
    });
}

Dans le fragment B, c'est-à-dire le fragment qui génère le résultat, définissez le résultat sur le même FragmentManager en utilisant le même élément requestKey. Pour ce faire, utilisez l'API setFragmentResult() :

button.setOnClickListener {
    val result = "result"
    // Use the Kotlin extension in the fragment-ktx artifact.
    setFragmentResult("requestKey", bundleOf("bundleKey" to result))
}

button.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        Bundle result = new Bundle();
        result.putString("bundleKey", "result");
        getParentFragmentManager().setFragmentResult("requestKey", result);
    }
});

Le fragment A reçoit ensuite le résultat et exécute le rappel de l'écouteur une fois que le fragment est lancé (STARTED).

Il ne peut y avoir qu'un seul écouteur et un seul résultat pour une clé donnée. Si vous appelez setFragmentResult() plusieurs fois pour la même clé et que l'écouteur n'est pas lancé (STARTED), le système remplace tous les résultats en attente par votre résultat mis à jour.

Si vous spécifiez un résultat sans qu'un écouteur correspondant ne soit prêt à le recevoir, il sera stocké dans le FragmentManager jusqu'à ce que vous définissiez un écouteur avec la même clé. Une fois qu'un écouteur reçoit un résultat et déclenche le rappel onFragmentResult(), le résultat est effacé. Ce comportement a deux conséquences majeures :

• Les fragments de la pile "Retour" ne reçoivent pas de résultats tant qu'ils n'ont pas été transmis et qu'ils ne sont pas lancés (STARTED).
• Si un fragment qui écoute un résultat est lancé (STARTED) lorsque le résultat est défini, le rappel de l'écouteur est déclenché immédiatement.

Tester les résultats du fragment

Utilisez FragmentScenario pour tester les appels à setFragmentResult() et setFragmentResultListener(). Créez un scénario pour le fragment testé en utilisant launchFragmentInContainer ou launchFragment, puis appelez manuellement la méthode qui n'est pas actuellement testée.

Pour tester setFragmentResultListener(), créez un scénario avec le fragment qui appelle setFragmentResultListener(). Appelez ensuite setFragmentResult() directement et vérifiez le résultat :

@Test
fun testFragmentResultListener() {
    val scenario = launchFragmentInContainer<ResultListenerFragment>()
    scenario.onFragment { fragment ->
        val expectedResult = "result"
        fragment.parentFragmentManager.setFragmentResult("requestKey", bundleOf("bundleKey" to expectedResult))
        assertThat(fragment.result).isEqualTo(expectedResult)
    }
}

class ResultListenerFragment : Fragment() {
    var result : String? = null
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // Use the Kotlin extension in the fragment-ktx artifact.
        setFragmentResultListener("requestKey") { requestKey, bundle ->
            result = bundle.getString("bundleKey")
        }
    }
}

Pour tester setFragmentResult(), créez un scénario avec le fragment qui appelle setFragmentResult(). Appelez ensuite setFragmentResultListener() directement et vérifiez le résultat :

@Test
fun testFragmentResult() {
    val scenario = launchFragmentInContainer<ResultFragment>()
    lateinit var actualResult: String?
    scenario.onFragment { fragment ->
        fragment.parentFragmentManager
                .setFragmentResultListener("requestKey") { requestKey, bundle ->
            actualResult = bundle.getString("bundleKey")
        }
    }
    onView(withId(R.id.result_button)).perform(click())
    assertThat(actualResult).isEqualTo("result")
}

class ResultFragment : Fragment(R.layout.fragment_result) {
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        view.findViewById(R.id.result_button).setOnClickListener {
            val result = "result"
            // Use the Kotlin extension in the fragment-ktx artifact.
            setFragmentResult("requestKey", bundleOf("bundleKey" to result))
        }
    }
}

Transmettre les résultats entre les fragments parents et enfants

Pour transmettre un résultat d'un fragment enfant à un parent, utilisez getChildFragmentManager() à partir du fragment parent au lieu de getParentFragmentManager() lors de l'appel de setFragmentResultListener().

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    // Set the listener on the child fragmentManager.
    childFragmentManager.setFragmentResultListener("requestKey") { key, bundle ->
        val result = bundle.getString("bundleKey")
        // Do something with the result.
    }
}

@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    // Set the listener on the child fragmentManager.
    getChildFragmentManager()
        .setFragmentResultListener("requestKey", this, new FragmentResultListener() {
            @Override
            public void onFragmentResult(@NonNull String requestKey, @NonNull Bundle bundle) {
                String result = bundle.getString("bundleKey");
                // Do something with the result.
            }
        });
}

Le fragment enfant définit le résultat sur son FragmentManager. Le parent reçoit ensuite le résultat une fois que le fragment est lancé (STARTED) :

button.setOnClickListener {
    val result = "result"
    // Use the Kotlin extension in the fragment-ktx artifact.
    setFragmentResult("requestKey", bundleOf("bundleKey" to result))
}

button.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {
        Bundle result = new Bundle();
        result.putString("bundleKey", "result");
        // The child fragment needs to still set the result on its parent fragment manager.
        getParentFragmentManager().setFragmentResult("requestKey", result);
    }
});

Recevoir les résultats dans l'activité de l'hôte

Pour recevoir un résultat de fragment dans l'activité de l'hôte, définissez un écouteur de résultat au niveau du gestionnaire de fragments à l'aide de getSupportFragmentManager().

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        supportFragmentManager
                .setFragmentResultListener("requestKey", this) { requestKey, bundle ->
            // We use a String here, but any type that can be put in a Bundle is supported.
            val result = bundle.getString("bundleKey")
            // Do something with the result.
        }
    }
}

class MainActivity extends AppCompatActivity {
    @Override
    public void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        getSupportFragmentManager().setFragmentResultListener("requestKey", this, new FragmentResultListener() {
            @Override
            public void onFragmentResult(@NonNull String requestKey, @NonNull Bundle bundle) {
                // We use a String here, but any type that can be put in a Bundle is supported.
                String result = bundle.getString("bundleKey");
                // Do something with the result.
            }
        });
    }
}