Comment puis-je obtenir le fragment actuellement affiché?
Je joue avec des fragments sous Android.
Je sais que je peux changer un fragment en utilisant le code suivant:
FragmentManager fragMgr = getSupportFragmentManager();
FragmentTransaction fragTrans = fragMgr.beginTransaction();
MyFragment myFragment = new MyFragment(); //my custom fragment
fragTrans.replace(Android.R.id.content, myFragment);
fragTrans.addToBackStack(null);
fragTrans.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE);
fragTrans.commit();
Ma question est, dans un fichier Java, comment puis-je obtenir l'instance de fragment actuellement affichée?
Lorsque vous ajoutez le fragment à votre transaction, vous devez utiliser une balise.
fragTrans.replace(Android.R.id.content, myFragment, "MY_FRAGMENT");
... et plus tard si vous voulez vérifier si le fragment est visible:
MyFragment myFragment = (MyFragment)getFragmentManager().findFragmentByTag("MY_FRAGMENT");
if (myFragment != null && myFragment.isVisible()) {
// add your code here
}
Voir aussi http://developer.Android.com/reference/Android/app/Fragment.html
Je sais que c'est un ancien post, mais j'avais déjà eu des problèmes avec lui aussi. J'ai trouvé une solution qui consistait à faire cela dans la fonction d'écoute onBackStackChanged()
@Override
public void onBackPressed() {
super.onBackPressed();
Fragment f = getActivity().getFragmentManager().findFragmentById(R.id.fragment_container);
if(f instanceof CustomFragmentClass)
// do something with f
((CustomFragmentClass) f).doSomething();
}
Cela a fonctionné pour moi car je ne voulais pas parcourir chaque fragment, il me fallait en trouver un visible. J'espère que ça aide quelqu'un d'autre aussi.
Voici ma solution que je trouve pratique pour les scénarios à faible fragment
public Fragment getVisibleFragment(){
FragmentManager fragmentManager = MainActivity.this.getSupportFragmentManager();
List<Fragment> fragments = fragmentManager.getFragments();
if(fragments != null){
for(Fragment fragment : fragments){
if(fragment != null && fragment.isVisible())
return fragment;
}
}
return null;
}
A chaque fois que vous montrez un fragment, vous devez le mettre dans la pile:
FragmentTransaction ft = getSupportFragmentManager().beginTransaction();
ft.setTransition(FragmentTransaction.TRANSIT_ENTER_MASK);
ft.add(R.id.primaryLayout, fragment, tag);
ft.addToBackStack(tag);
ft.commit();
Et ensuite, lorsque vous aurez besoin du fragment actuel, vous pourrez utiliser cette méthode:
public BaseFragment getActiveFragment() {
if (getSupportFragmentManager().getBackStackEntryCount() == 0) {
return null;
}
String tag = getSupportFragmentManager().getBackStackEntryAt(getSupportFragmentManager().getBackStackEntryCount() - 1).getName();
return (BaseFragment) getSupportFragmentManager().findFragmentByTag(tag);
}
Ce que j'utilise pour trouver le fragment d'affichage actuel se trouve dans le code ci-dessous. C'est simple et ça marche pour moi maintenant. Il court dans l'activité qui contient les fragments
FragmentManager fragManager = this.getSupportFragmentManager();
int count = this.getSupportFragmentManager().getBackStackEntryCount();
Fragment frag = fragManager.getFragments().get(count>0?count-1:count);
Le réactif moyen:
Observable.from(getSupportFragmentManager().getFragments())
.filter(fragment -> fragment.isVisible())
.subscribe(fragment1 -> {
// Do something with it
}, throwable1 -> {
//
});
Ma méthode est basée sur try/catch comme ceci:
MyFragment viewer = null;
try {
viewer = (MyFragment) getFragmentManager().findFragmentByTag(MY_TAG_FRAGMENT);
} catch (ClassCastException e) {
// not that fragment
}
Mais il y a peut-être un meilleur moyen ...
Il est un peu tard, mais pour tous ceux qui sont intéressés: Si vous connaissez l'index du fragment souhaité dans FragmentManager, obtenez-y une référence et vérifiez la fonction isMenuVisible ()! ici :
getSupportFragmentManager().getFragments().get(0).isMenuVisible()
Si true C'est visible pour l'utilisateur et ainsi de suite!
Eh bien, cette question a attiré beaucoup d’attention et d’attention, mais ne contenait toujours pas La solution la plus simple de mon côté - utiliser getFragments ().
List fragments = getSupportFragmentManager().getFragments();
mCurrentFragment = fragments.get(fragments.size() - 1);
1)
ft.replace(R.id.content_frame, fragment, **tag**).commit();
2)
FragmentManager fragmentManager = getSupportFragmentManager();
Fragment currentFragment = fragmentManager.findFragmentById(R.id.content_frame);
3)
if (currentFragment.getTag().equals(**"Fragment_Main"**))
{
//Do something
}
else
if (currentFragment.getTag().equals(**"Fragment_DM"**))
{
//Do something
}
Il existe une méthode appelée findFragmentById() dans SupportFragmentManager. Je l'utilise dans le conteneur d'activité comme:
public Fragment currentFragment(){
return getSupportFragmentManager().findFragmentById(R.id.activity_newsfeed_frame);
}
Voilà comment obtenir votre Fragment actuelle. Si vous avez personnalisé Fragment et devez vérifier en quoi consiste Fragment, j’utilise normalement instanceof:
if (currentFragment() instanceof MyFrag){
// Do something here
}
Inspiré par la réponse de Tainy , voici mes deux sous. Peu modifié de la plupart des autres implémentations.
private Fragment getCurrentFragment() {
FragmentManager fragmentManager = myActivity.getSupportFragmentManager();
int stackCount = fragmentManager.getBackStackEntryCount();
if( fragmentManager.getFragments() != null ) return fragmentManager.getFragments().get( stackCount > 0 ? stackCount-1 : stackCount );
else return null;
}
Remplacez "myActivity" par "ceci" s'il s'agit de votre activité actuelle ou utilisez la référence à votre activité.
La réponse de Sev fonctionne lorsque vous appuyez sur le bouton Retour ou modifiez le backstack.
J'ai fait quelque chose de légèrement différent, cependant. J'ai une configuration d'écouteur de changement de pile sur un fragment de base et ses fragments dérivés et ce code est dans l'écouteur:
Fragment f = getActivity().getSupportFragmentManager().findFragmentById(R.id.container);
if (f.getClass().equals(getClass())) {
// On back button, or popBackStack(),
// the fragment that's becoming visible executes here,
// but not the one being popped, or others on the back stack
// So, for my case, I can change action bar bg color per fragment
}
C'est un moyen simple d'obtenir le fragment actuel ..
getFragmentManager().addOnBackStackChangedListener(new FragmentManager.OnBackStackChangedListener() {
@Override public void onBackStackChanged() {
currentFragment = fragmentManager.findFragmentById(R.id.content);
if (currentFragment != null && (currentFragment instanceof LoginScreenFragment)) {
logout.setVisibility(View.GONE);
} else {
logout.setVisibility(View.VISIBLE);
}
}
});
Vous pouvez demander quel fragment est chargé dans votre cadre de contenu Activités et récupérer la classe de fragment, ou fragment 'nom simple' (sous forme de chaîne).
public String getCurrentFragment(){
return activity.getSupportFragmentManager().findFragmentById(R.id.content_frame).getClass().getSimpleName();
}
Usage:
Log.d(TAG, getCurrentFragment());
Les sorties:
D/MainActivity: FragOne
C'est un travail pour moi. J'espère que cela aidera quelqu'un.
FragmentManager fragmentManager = this.getSupportFragmentManager();
String tag = fragmentManager
.getBackStackEntryAt(
fragmentManager
.getBackStackEntryCount() - 1)
.getName();
Log.d("This is your Top Fragment name: ", ""+tag);
Si vous arrivez ici et que vous utilisez Kotlin:
var fragment = supportFragmentManager.findFragmentById(R.id.fragment_container)
R.id.fragment_container est la id où la fragment se présente sur leur activity
Ou si vous voulez une solution plus agréable:
supportFragmentManager.findFragmentById(R.id.content_main)?.let {
// the fragment exists
if (it is FooFragment) {
// The presented fragment is FooFragment type
}
}
Si vous obtenez l’instance actuelle de Fragment à partir de l’activité parent, vous pouvez simplement
findFragmentByID(R.id.container);
Il s’agit en fait de l’instance actuelle de fragment renseignée dans la vue. J'ai eu le même problème. J'ai dû charger le même fragment deux fois et en garder un sur le tapis.
La méthode suivante ne fonctionne pas. Il y a juste un fragment qui a l'étiquette. Ne perdez pas votre temps avec cette méthode. Je suis sûr que cela a ses utilisations, mais obtenir la version la plus récente du même fragment n'en fait pas partie.
findFragmentByTag()
final FragmentManager fm=this.getSupportFragmentManager();
final Fragment fragment=fm.findFragmentByTag("MY_FRAGMENT");
if(fragment != null && fragment.isVisible()){
Log.i("TAG","my fragment is visible");
}
else{
Log.i("TAG","my fragment is not visible");
}
Commander cette solution. Cela a fonctionné pour moi pour obtenir le fragment actuel.
if(getSupportFragmentManager().getBackStackEntryCount() > 0){
Android.support.v4.app.Fragment f =
getSupportFragmentManager().findFragmentById(R.id.fragment_container);
if(f instanceof ProfileFragment){
Log.d(TAG, "Profile Fragment");
}else if(f instanceof SavedLocationsFragment){
Log.d(TAG, "SavedLocations Fragment");
}else if(f instanceof AddLocationFragment){
Log.d(TAG, "Add Locations Fragment");
}
J'ai rencontré un problème similaire dans lequel je voulais savoir quel fragment était affiché pour la dernière fois lorsque la touche Retour était enfoncée. J'ai utilisé une solution très simple qui a fonctionné pour moi. Chaque fois que j'ouvre un fragment, dans la méthode onCreate (), je définis une variable dans mon singleton (remplace "myFragment" par le nom de votre fragment).
MySingleton.currentFragment = myFragment.class;
La variable est déclarée dans le singleton comme
public static Class currentFragment = null;
Puis dans le onBackPressed () je vérifie
if (MySingleton.currentFragment == myFragment.class){
// do something
return;
}
super.onBackPressed();
Assurez-vous d'appeler le super.onBackPressed (); après le "retour", sinon l'application traitera la clé de retour, ce qui dans mon cas a entraîné la fermeture de l'application.
Dans le cas de fragments défilés, lorsque votre instance d'utilisation de la classe ViewPager, supposez mVeiwPager, vous pouvez appeler mViewPager.getCurrentItem () pour obtenir le numéro actuel du fragment.
dans MainLayout.xml
<?xml version="1.0" encoding="utf-8"?>
<Android.support.design.widget.CoordinatorLayout xmlns:Android="http://schemas.Android.com/apk/res/Android"
xmlns:app="http://schemas.Android.com/apk/res-auto"
xmlns:tools="http://schemas.Android.com/tools"
Android:layout_width="match_parent"
Android:layout_height="match_parent"
Android:fitsSystemWindows="true"
Android:orientation="vertical"
tools:context="unidesign.photo360.MainActivity">
<Android.support.design.widget.AppBarLayout
Android:id="@+id/appbar"
Android:layout_width="match_parent"
Android:layout_height="wrap_content"
Android:fitsSystemWindows="false"
Android:theme="@style/AppTheme.AppBarOverlay"
app:expanded="false">
<Android.support.v7.widget.Toolbar
Android:id="@+id/main_activity_toolbar"
Android:layout_width="match_parent"
Android:layout_height="wrap_content"
Android:layout_weight="1"
app:popupTheme="@style/AppTheme.PopupOverlay"
app:title="@string/app_name">
</Android.support.v7.widget.Toolbar>
</Android.support.design.widget.AppBarLayout>
<Android.support.v4.view.ViewPager
Android:id="@+id/view_pager"
Android:layout_width="match_parent"
Android:layout_height="wrap_content">
</Android.support.v4.view.ViewPager>
</Android.support.design.widget.CoordinatorLayout>dans MainActivity.kt
class MainActivity : AppCompatActivity() {
lateinit var mViewPager: ViewPager
lateinit var pageAdapter: PageAdapter
// ...
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
pageAdapter = PageAdapter(supportFragmentManager)
mViewPager = findViewById(R.id.view_pager)
// ...
}
override fun onResume() {
super.onResume()
var currentFragment = pageAdapter.getItem(mViewPager.currentItem)
// ...
}getSupportFragmentManager().findFragmentById(R.id.content_frame).getClass().getSimpleName();
Eh bien, je suppose que c'est la réponse la plus directe à cette question. J'espère que ça aide.
Façon Kotlin;
val currentFragment = supportFragmentManager.fragments.last()
Dans l'activité principale, la méthode onAttachFragment (fragment de fragment) est appelée lorsqu'un nouveau fragment est attaché à l'activité. Dans cette méthode, vous pouvez obtenir l'instance du fragment en cours. Cependant, la méthode onAttachFragment n'est pas appelée lorsqu'un fragment est extrait de la pile, c'est-à-dire lorsque le bouton Précédent est enfoncé pour obtenir le fragment supérieur au-dessus de la pile. Je suis toujours à la recherche d'une méthode de rappel déclenchée dans l'activité principale lorsqu'un fragment devient visible à l'intérieur de l'activité.
J'ai aussi collé sur ce point. Ce que j'ai finalement fait, vient de déclarer un tableau de fragments:
private static PlaceholderFragment[] arrFrg;
(dans mon cas, il s'agit de PlaceholderFragment) et a emballé tous les Fragemnts de ce thessess dans ce tableau sans marquage :)
public static PlaceholderFragment newInstance(int sectionNumber) {
final PlaceholderFragment fragment = new PlaceholderFragment();
Bundle args = new Bundle();
args.putInt(ARG_SECTION_NUMBER, sectionNumber);
fragment.setArguments(args);
arrFrg[sectionNumber] = fragment;
return fragment;
}
Ensuite, vous pouvez facilement accéder au fragment actuellement affiché:
arrFrg[mViewPager.getCurrentItem()];
Je comprends, ce n’est probablement pas la meilleure solution, mais cela fonctionne parfaitement pour moi :)
public Fragment getVisibleFragment() {
FragmentManager fragmentManager = getSupportFragmentManager();
List<Fragment> fragments = fragmentManager.getFragments();
if(fragments != null) {
for (Fragment fragment : fragments) {
if (fragment != null && fragment.isVisible())
return fragment;
}
}
return null;
}
Cela fonctionne pour moi. Vous devez effectuer une vérification nulle avant de parcourir la liste des fragments. Il pourrait y avoir un scénario selon lequel aucun fragment n'est chargé sur la pile.
Le fragment renvoyé peut être comparé au fragment que vous souhaitez mettre sur la pile.
Vous pouvez obtenir le fragment actuel en utilisant le code suivant
FragmentClass f = (FragmentClass)viewPager.getAdapter().instantiateItem(viewPager, viewPager.getCurrentItem());
Si vous avez des fragments imbriqués, comme des viewpagers dans des viewpagers, etc. et que vous voulez obtenir tous les fragments imbriqués.
Merci et courtoisie de Matt Mombrea répond une version légèrement modifiée.
private List<Fragment> getVisibleFragments(List<Fragment> searchFragments, List<Fragment> visibleFragments) {
if (searchFragments != null && searchFragments.size() > 0) {
for (Fragment fragment : searchFragments) {
List<Fragment> nestedFragments = new ArrayList<>();
List<Fragment> childFMFragments = fragment.getChildFragmentManager().getFragments();
List<Fragment> fmFragments = fragment.getFragmentManager().getFragments();
fmFragments.retainAll(childFMFragments);
nestedFragments.addAll(childFMFragments);
nestedFragments.addAll(fmFragments);
getVisibleFragments(nestedFragments, visibleFragments);
if (fragment != null && fragment.isVisible()) {
visibleFragments.add(fragment);
}
}
}
return visibleFragments;
}
Et voici l'usage:
List<Fragment> allVisibleFragments = getVisibleFragments(searchFragments, visibleFragments);
Par exemple:
List<Fragment> visibleFragments = new ArrayList<>();
List<Fragment> searchFragments = MainActivity.this.getSupportFragmentManager().getFragments();
Toast.makeText(this, ""+getVisibleFragments(searchFragments, visibleFragments), Toast.LENGTH_LONG).show();
Si vous utilisez la bibliothèque de support v13, ce problème est résolu et vous devez simplement remplacer:
@Override
public void setUserVisibleHint(boolean isVisibleToUser)
{
// TODO Auto-generated method stub
super.setUserVisibleHint(isVisibleToUser);
}
Le fait est que vous ne pouvez pas mélanger les deux car le fragment n’est pas compatible avec la classe de fragments de la version 4.
Si vous n'utilisez pas la librairie de support V4, remplacez la méthode setPrimaryItem par votre FragmentStatePagerAdapter.
J'utilisais cela pour mettre à jour le titre Actionbat dans les grandes listes.
Un peu étrange, mais j'ai regardé FragmentManager $ FragmentManagerImpl et le suivant fonctionne pour moi:
public static Fragment getActiveFragment(Activity activity, int index)
{
Bundle bundle = new Bundle();
String key = "i";
bundle.putInt(key,index);
Fragment fragment=null;
try
{
fragment = activity.getFragmentManager().getFragment(bundle, key);
} catch(Exception e){}
return fragment;
}
pour obtenir le premier fragment actif, utilisez 0 comme index
L'utilisation d'un bus d'événement (comme Otto , EventBus ou un RxJava Bus ) est particulièrement pratique dans ces situations.
Bien que cette approche ne vous transfère pas nécessairement le fragment actuellement visible en tant qu’objet (bien que cela puisse aussi être fait mais elle entraîne une chaîne d’appel plus longue), elle vous permet d’exécuter des actions sur le fragment actuellement visible vouloir faire en connaissant le fragment actuellement visible).
- assurez-vous de respecter le cycle de vie des fragments et enregistrez/annulez l'enregistrement du bus d'événement aux moments appropriés
- au point où vous devez connaître le fragment actuellement visible et exécuter un ensemble d’actions. tirer un événement avec le bus de l'événement.
tous les fragments visibles enregistrés sur le bus exécuteront l'action nécessaire.
Bonjour, je sais que c’est un problème très ancien, mais j’aimerais partager ma propre solution.
Afin d'obtenir la liste des fragments parcourus par l'utilisateur, j'ai créé une classe d'assistance:
public class MyHelperClass{
private static ArrayList<Fragment> listFragment = new ArrayList<>();
public static void addFragment(Fragment f){
if(!existFragment(f)) {
listFragment.add(f);
}
}
public static void removeFragment(){
if(listFragment.size()>0)
listFragment.remove(listFragment.size()-1);
}
public static Fragment getCurrentFragment(){
return listFragment.get(listFragment.size()-1);
}
public static int sizeFragments(){
return listFragment.size();
}
private static Boolean existFragment(Fragment f){
Boolean ret = false;
for(Fragment fragment : listFragment){
if (fragment.getClass() == f.getClass()){
ret = true;
}
}
return ret;
}
Et dans l'activité principale, je remplace la méthode onAttachFragment
@Override
public void onAttachFragment(Fragment f) {
super.onAttachFragment(f);
MyHelperClass.addFragment(f);
}
et aussi, je remplace la méthode onBackPressed:
@Override
public void onBackPressed() {
General.removeFragment();
if(General.sizeFragments()>0){
Fragment fragment = null;
Class fragmentClass = General.getCurrentFragment().getClass();
try {
fragment = (Fragment) fragmentClass.newInstance();
fragment.setArguments(General.getCurrentFragment().getArguments());
} catch (Exception e) {
e.printStackTrace();
}
fragmentManager.beginTransaction().replace(R.id.flContent, fragment).commit();
}else{
super.onBackPressed();
}
}
de cette manière, vous pouvez obtenir à tout moment le fragment actif avec MyHelperClass.getCurrentFragment ()
J'espère que cela sera utile à quiconque
cordialement
Vous pouvez ajouter une variable de classe selectedFragment et, chaque fois que vous modifiez le fragment, vous mettez à jour la variable.
public Fragment selectedFragment;
public void changeFragment(Fragment newFragment){
FragmentManager fragMgr = getSupportFragmentManager();
FragmentTransaction fragTrans = fragMgr.beginTransaction();
fragTrans.replace(Android.R.id.content, newFragment);
fragTrans.addToBackStack(null);
fragTrans.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE);
fragTrans.commit();
//here you update the variable
selectedFragment = newFragment;
}
alors vous pouvez utiliser selectedFragment où vous voulez
Peut-être que le moyen le plus simple est:
public MyFragment getVisibleFragment(){
FragmentManager fragmentManager = MainActivity.this.getSupportFragmentManager();
List<Fragment> fragments = fragmentManager.getFragments();
for(Fragment fragment : fragments){
if(fragment != null && fragment.getUserVisibleHint())
return (MyFragment)fragment;
}
return null;
}
Ça a fonctionné pour moi
J'ai dû faire cela très récemment et aucune des réponses ici ne correspondait vraiment à ce scénario.
Si vous êtes sûr que seul un fragment sera visible (plein écran), vous voulez donc vraiment trouver ce qui se trouve en haut du dossier. Par exemple, en tant que Kotlin pour Fragment:
import androidx.fragment.app.Fragment
fun Fragment.setVisibilityChangeListener(clazz: Class<out Fragment>, listener: (Boolean) -> Unit) {
fragmentManager?.run {
addOnBackStackChangedListener {
val topFragmentTag = getBackStackEntryAt(backStackEntryCount - 1).name
val topFragment = findFragmentByTag(topFragmentTag)
listener(topFragment != null && topFragment::class.Java == clazz)
}
}
}
Et utilisez-le comme:
class MyFragment: Fragment {
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
setVisibilityChangeListener(this::class.Java) { visible ->
// Do stuff
}
}
}
J'ai trouvé que findFragmentByTag n'est pas si pratique. Si vous avez String currentFragmentTag dans votre Activity ou parent Fragment, vous devez l'enregistrer dans onSaveInstanceState et le restaurer dans onCreate. Même si vous le faites, lorsque Activity est recréé, onAttachFragment sera appelé avant onCreate, de sorte que vous ne pouvez pas utiliser currentFragmentTag dans onAttachFragment (par exemple, mettre à jour certaines vues en fonction de currentFragmentTag), car elle risque de ne pas être restaurée.
J'utilise le code suivant:
Fragment getCurrentFragment() {
List<Fragment> fragments = getSupportFragmentManager().getFragments();
if(fragments.isEmpty()) {
return null;
}
return fragments.get(fragments.size()-1);
}
Le document de FragmentManager indique que
L'ordre des fragments dans la liste correspond à l'ordre dans lequel ils ont été ajoutés ou joints.
Lorsque vous avez besoin d'effectuer des tâches en fonction du type de fragment actuel, utilisez simplement getCurrentFragment() instance of MyFragment au lieu de currentFragmentTag.equals("my_fragment_tag").
Notez que getCurrentFragment() dans onAttachFragment n'obtiendra pas la Fragment attachée, mais la précédente attachée.
c'est la meilleur façon:
Android.app.Fragment currentFragment=getFragmentManager().findFragmentById(R.id.main_container);
if(currentFragment!=null)
{
String[] currentFragmentName = currentFragment.toString().split("\\{");
if (currentFragmentName[0].toString().equalsIgnoreCase("HomeSubjectFragment"))
{
fragment = new HomeStagesFragment();
tx = getSupportFragmentManager().beginTransaction();
tx.replace(R.id.main_container, fragment);
tx.addToBackStack(null);
tx.commit();
}
else if(currentFragmentName[0].toString().equalsIgnoreCase("HomeStagesFragment"))
{
new AlertDialog.Builder(this)
.setMessage("Are you sure you want to exit?")
.setCancelable(false)
.setPositiveButton("Yes", new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int id) {
finish();
}
})
.setNegativeButton("No", null)
.show();
}
}
n'oubliez pas de définir ceci dans l'en-tête:
private Fragment fragment;
FragmentTransaction tx;
S'il vous plaît essayez cette méthode .....
private Fragment getCurrentFragment(){
FragmentManager fragmentManager = getSupportFragmentManager();
String fragmentTag = fragmentManager.getBackStackEntryAt(fragmentManager.getBackStackEntryCount() - 1).getName();
Fragment currentFragment = getSupportFragmentManager()
.findFragmentByTag(fragmentTag);
return currentFragment;
}
si getFragmentManager () ne fonctionne pas, essayez avec getSupportFragmentManager () et ajoutez une balise au moment du chargement du fragment.
public void onBackPressed(){
Fragment fragment=getSupportFragmentManager().findFragmentByTag(/*enter your tag*/);
if(fragment!=null && fragment.isVisible())
{
//do your code here
}
else
{
//do your code here
}
}
eh bien, je pense que vous voulez voir dans quel fragment vous êtes Je suppose qu'il y a une demande que je ne pense pas que ce soit le meilleur mais cela fonctionne Tout d'abord
vous devez créer votre fragment parent qu'il étend Fragment
public class Fragment2 extends Fragment {
private static position;
public static int getPosition() {
return position;
}
public static void setPosition(int position) {
FragmentSecondParent.position = position;
}
}
Seconde
vous devriez l'étendre dans chaque fragment et dans chaque écriture dans onCreateView
setPosition(//your fragmentposition here)
Troisième
où vous voulez obtenir le fragment actuel, vous devriez
écrire cela
Fragment2 fragment= (Fragment2) getSupportFragmentManager()
.findFragmentById(R.id.fragment_status);
int position = fragment.getPosition();
if(//position condition)
{
//your code here
}