Abrufen der aktuellen Fragmentinstanz im Viewpager

Unten ist mein Code, in den 3 Fragment classesjeweils die drei Registerkarten eingebettet sind ViewPager. Ich habe eine Menüoption. Wie in der Abbildung gezeigt onOptionsItemSelected(), muss ich durch Auswahl einer Option das derzeit sichtbare Fragment aktualisieren. Um dies zu aktualisieren, muss ich eine Methode aufrufen, die sich in der Fragmentklasse befindet. Kann jemand bitte vorschlagen, wie man diese Methode aufruft?

public class MainActivity  extends ActionBarActivity {

     ViewPager ViewPager;
     TabsAdapter TabsAdapter;

     @Override
        public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);

            ViewPager = new ViewPager(this);
            ViewPager.setId(R.id.pager);
            setContentView(ViewPager);

            final ActionBar bar = getSupportActionBar();

            bar.setNavigationMode(ActionBar.NAVIGATION_MODE_TABS);

            //Attaching the Tabs to the fragment classes and setting the tab title.
            TabsAdapter = new TabsAdapter(this, ViewPager);
            TabsAdapter.addTab(bar.newTab().setText("FragmentClass1"),
                    FragmentClass1.class, null);
            TabsAdapter.addTab(bar.newTab().setText("FragmentClass2"),
              FragmentClass2.class, null);
            TabsAdapter.addTab(bar.newTab().setText("FragmentClass3"),
              FragmentClass3.class, null);


            if (savedInstanceState != null) {
                bar.setSelectedNavigationItem(savedInstanceState.getInt("tab", 0));
            }

        }

        @Override
        public boolean onOptionsItemSelected(MenuItem item) {

            switch (item.getItemId()) {

            case R.id.addText:

           **// Here I need to call the method which exists in the currently visible Fragment class**

                    return true;

            }

            return super.onOptionsItemSelected(item);
        }


     @Override
     protected void onSaveInstanceState(Bundle outState) {
      super.onSaveInstanceState(outState);
            outState.putInt("tab", getSupportActionBar().getSelectedNavigationIndex());

     }

     public static class TabsAdapter extends FragmentPagerAdapter
      implements ActionBar.TabListener, ViewPager.OnPageChangeListener {

      private final Context mContext;
            private final ActionBar mActionBar;
            private final ViewPager mViewPager;
            private final ArrayList<TabInfo> mTabs = new ArrayList<TabInfo>();

            static final class TabInfo {
                private final Class<?> clss;
                private final Bundle args;

                TabInfo(Class<?> _class, Bundle _args) {
                    clss = _class;
                    args = _args;
                }
            }

      public TabsAdapter(ActionBarActivity activity, ViewPager pager) {
       super(activity.getSupportFragmentManager());
                mContext = activity;
                mActionBar = activity.getSupportActionBar();
                mViewPager = pager;
                mViewPager.setAdapter(this);
                mViewPager.setOnPageChangeListener(this);
            }

      public void addTab(ActionBar.Tab tab, Class<?> clss, Bundle args) {
                TabInfo info = new TabInfo(clss, args);
                tab.setTag(info);
                tab.setTabListener(this);
                mTabs.add(info);
                mActionBar.addTab(tab);
                notifyDataSetChanged();

            }

      @Override
      public void onPageScrollStateChanged(int state) {
       // TODO Auto-generated method stub

      }

      @Override
      public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {
       // TODO Auto-generated method stub

      }

      @Override
      public void onPageSelected(int position) {
       // TODO Auto-generated method stub
       mActionBar.setSelectedNavigationItem(position);
      }

      @Override
      public void onTabReselected(Tab tab, FragmentTransaction ft) {
       // TODO Auto-generated method stub

      }

      @Override
      public void onTabSelected(Tab tab, FragmentTransaction ft) {
       Object tag = tab.getTag();
                for (int i=0; i<mTabs.size(); i++) {
                    if (mTabs.get(i) == tag) {
                        mViewPager.setCurrentItem(i);

                    }
                }

                tabPosition = tab.getPosition();
      }

      @Override
      public void onTabUnselected(Tab tab, FragmentTransaction ft) {
       // TODO Auto-generated method stub

      }

      @Override
      public Fragment getItem(int position) {
       TabInfo info = mTabs.get(position);
                return Fragment.instantiate(mContext, info.clss.getName(), info.args);
      }

      @Override
      public int getCount() {
       return mTabs.size();
      }

     }

    }

Angenommen, unten ist die Fragmentklasse mit der Methode, die updateList()ich aufrufen möchte:

 public class FragmentClass1{

    ArrayList<String> originalData;


    @Override
         public View onCreateView(LayoutInflater inflater, ViewGroup container,
           Bundle savedInstanceState) {

          View fragmentView = inflater.inflate(R.layout.frag1, container, false);

          originalData = getOriginalDataFromDB();

          return fragmentView;

         }


    public void updateList(String text)
    {
       originalData.add(text);
       //Here I could do other UI part that need to added
    }
}

Durch Auswahl einer Option muss das aktuell sichtbare Fragment aktualisiert werden.

Eine einfache Möglichkeit hierfür ist die Verwendung eines Tricks im Zusammenhang mit der FragmentPagerAdapterImplementierung:

case R.id.addText:
     Fragment page = getSupportFragmentManager().findFragmentByTag("android:switcher:" + R.id.pager + ":" + ViewPager.getCurrentItem());
     // based on the current position you can then cast the page to the correct 
     // class and call the method:
     if (ViewPager.getCurrentItem() == 0 && page != null) {
          ((FragmentClass1)page).updateList("new item");     
     } 
return true;

Bitte überdenken Sie Ihre Namenskonvention für Variablen. Verwenden Sie als Variablennamen den Namen der Klasse, der sehr verwirrend ist (also nein ViewPager ViewPager, verwenden Sie ViewPager mPagerzum Beispiel).

    public class MyPagerAdapter extends FragmentPagerAdapter {
        private Fragment mCurrentFragment;

        public Fragment getCurrentFragment() {
            return mCurrentFragment;
        }
//...    
        @Override
        public void setPrimaryItem(ViewGroup container, int position, Object object) {
            if (getCurrentFragment() != object) {
                mCurrentFragment = ((Fragment) object);
            }
            super.setPrimaryItem(container, position, object);
        }
    }

Verfolgen Sie zunächst alle "aktiven" Fragmentseiten. In diesem Fall verfolgen Sie die Fragmentseiten im FragmentStatePagerAdapter, der vom ViewPager verwendet wird.

@Override
public Fragment getItem(int index) {
    Fragment myFragment = MyFragment.newInstance();
    mPageReferenceMap.put(index, myFragment);
    return myFragment;
}

Um zu vermeiden, dass ein Verweis auf "inaktive" Fragmentseiten beibehalten wird, müssen Sie die destroyItem (...) -Methode des FragmentStatePagerAdapter implementieren:

@Override
public void destroyItem (ViewGroup container, int position, Object object) {
    super.destroyItem(container, position, object);
    mPageReferenceMap.remove(position);
}

und wenn Sie auf die aktuell sichtbare Seite zugreifen müssen, rufen Sie an:

int index = mViewPager.getCurrentItem();
MyAdapter adapter = ((MyAdapter)mViewPager.getAdapter());
MyFragment fragment = adapter.getFragment(index);

Wo die getFragment (int) -Methode des MyAdapters folgendermaßen aussieht:

public MyFragment getFragment(int key) {
    return mPageReferenceMap.get(key);
}

Hoffe es kann helfen!

Nur so erhalte ich keine NullPointerException für die Instanzvariablen dieser bestimmten Fragmentklassen. Dies kann für andere hilfreich sein, die an der gleichen Sache festhalten. In onOptionsItemSelected () habe ich den folgenden Weg codiert:

if(viewPager.getCurrentItem() == 0) {
    FragmentClass1 frag1 = (FragmentClass1)viewPager
                            .getAdapter()
                            .instantiateItem(viewPager, viewPager.getCurrentItem());
    frag1.updateList(text); 
} else if(viewPager.getCurrentItem() == 1) {
    FragmentClass2 frag2 = (FragRecentApps)viewPager
                            .getAdapter()
                            .instantiateItem(viewPager, viewPager.getCurrentItem());
    frag2.updateList(text);
}

FragmentStatePagerAdapter verfügt über eine öffentliche Methode mit dem Namen instantiateItem, die Ihr Fragment basierend auf angegebenen Parameterwerten zurückgibt. Diese Methode verfügt über zwei Parameter ViewGroup (ViewPager) und position.

public Object instantiateItem(ViewGroup container, int position);

Verwendete diese Methode, um das Fragment der angegebenen Position abzurufen.

Fragment fragment = (Fragment) adaper.instantiateItem(mViewPager, position);

Ich weiß, dass es zu spät ist, aber ich habe wirklich einfache Möglichkeiten, es zu tun,

// für Fragment bei 0 Besitz

((mFragment) viewPager.getAdapter().instantiateItem(viewPager, 0)).yourMethod();

Hier gibt es viele Antworten, die nicht wirklich die grundlegende Tatsache ansprechen, dass es wirklich KEINE MÖGLICHKEIT gibt, dies vorhersehbar zu tun, und auf eine Weise, die nicht dazu führt, dass Sie sich irgendwann in der Zukunft in den Fuß schießen.

FragmentStatePagerAdapter ist die einzige Klasse, die weiß, wie sie zuverlässig auf die Fragmente zugreifen kann, die von der verfolgt werden FragmentManager - Jeder Versuch, die ID oder das Tag des Fragments zu erraten, ist langfristig nicht zuverlässig. Und Versuche, die Instanzen manuell zu verfolgen, funktionieren wahrscheinlich nicht gut, wenn der Status gespeichert / wiederhergestellt wird, weilFragmentStatePagerAdapter die Rückrufe möglicherweise nicht aufgerufen werden, wenn der Status wiederhergestellt wird.

Das einzige, wofür ich arbeiten konnte, ist das Kopieren des Codes für FragmentStatePagerAdapter und das Hinzufügen einer Methode, die das Fragment bei gegebener Position zurückgibt ( mFragments.get(pos)). Beachten Sie, dass diese Methode davon ausgeht, dass das Fragment tatsächlich verfügbar ist (dh es war irgendwann sichtbar).

Wenn Sie besonders abenteuerlustig sind, können Sie mithilfe der Reflexion auf die Elemente der privaten mFragmentsListe zugreifen , aber dann kehren wir zum ersten Punkt zurück (der Name der Liste bleibt garantiert nicht gleich).

getSupportFragmentManager().getFragments().get(viewPager.getCurrentItem());

Wandeln Sie die von der obigen Zeile empfangene Instanz in das Fragment um, mit dem Sie arbeiten möchten. Funktioniert einwandfrei.

viewPager

ist die Pager-Instanz, die die Fragmente verwaltet.

Durch Auswahl einer Option muss das aktuell sichtbare Fragment aktualisiert werden.

Angenommen, Sie haben einen Verweis auf ViewPageras, um einen Verweis auf das aktuell sichtbare Fragment zu erhalten mPager. Die folgenden Schritte erhalten dann einen Verweis auf currentFragment:

1. PageAdapter adapter = mPager.getAdapter();
2. int fragmentIndex = mPager.getCurrentItem();
3. FragmentStatePagerAdapter fspa = (FragmentStatePagerAdapter)adapter;
4. Fragment currentFragment = fspa.getItem(fragmentIndex);

Die einzige Besetzung, die in Zeile 3 verwendet wird, ist normalerweise gültig. FragmentStatePagerAdapterist ein nützlicher Adapter für einen ViewPager.

Rufen Sie am besten einfach CallingFragmentName auf fragment = (CallingFragmentName) viewPager .getAdapter () .instantiateItem (viewPager, viewPager.getCurrentItem ()); Das aufrufende Fragment wird erneut instanziiert, sodass keine Nullzeigerausnahme ausgelöst und keine Methode dieses Fragments aufgerufen wird.

Aktuelles Fragment:

Dies funktioniert, wenn Sie ein Projekt mit der Registerkartenvorlage Fragmente erstellt haben.

Fragment f = mSectionsPagerAdapter.getItem(mViewPager.getCurrentItem());

Beachten Sie, dass dies mit der Standardimplementierung von Aktivitätsvorlagen mit Registerkarten funktioniert.

Ich habe folgendes verwendet:

 int index = vpPager.getCurrentItem();
 MyPagerAdapter adapter = ((MyPagerAdapter)vpPager.getAdapter());
 MyFragment suraVersesFragment = (MyFragment)adapter.getRegisteredFragment(index);

FragmentStatePagerAdapterhat eine private Instanzvariable mCurrentPrimaryItemvom Typ Fragment. Man kann sich nur fragen, warum Android-Entwickler es nicht mit einem Getter geliefert haben. Diese Variable wird in der setPrimaryItem()Methode instanziiert . Überschreiben Sie diese Methode also so, dass Sie den Verweis auf diese Variable erhalten. Am Ende habe ich einfach meine eigenen deklariert mCurrentPrimaryItemund den Inhalt von kopiertsetPrimaryItem() meiner Überschreibung .

Bei Ihrer Implementierung von FragmentStatePagerAdapter:

private Fragment mCurrentPrimaryItem = null;

@Override
public void setPrimaryItem(ViewGroup container, int position, Object object) {
    Fragment fragment = (Fragment)object;
    if (fragment != mCurrentPrimaryItem) {
        if (mCurrentPrimaryItem != null) {
            mCurrentPrimaryItem.setMenuVisibility(false);
            mCurrentPrimaryItem.setUserVisibleHint(false);
        }
        if (fragment != null) {
            fragment.setMenuVisibility(true);
            fragment.setUserVisibleHint(true);
        }
        mCurrentPrimaryItem = fragment;
    }
}

public TasksListFragment getCurrentFragment() {
    return (YourFragment) mCurrentPrimaryItem;
}

Sie können die definieren , PagerAdapterwie dies dann können Sie alle bekommen Fragmentin ViewPager.

private class PagerAdapter extends FragmentPagerAdapter {
    private final List<Fragment> mFragmentList = new ArrayList<>();

    public PagerAdapter(FragmentManager fm) {
        super(fm);
    }

    @Override
    public Fragment getItem(int position) {
        return mFragmentList.get(position);
    }

    @Override
    public int getCount() {
        return mFragmentList.size();
    }

    public void addFragment(Fragment fragment) {
        mFragmentList.add(fragment);
    }
}

Um den Strom zu bekommen Fragment

Fragment currentFragment = mPagerAdapter.getItem(mViewPager.getCurrentItem());

Wenn wir den viewPager verwenden, ist instantiateItem (viewpager, index) eine gute Möglichkeit, in Aktivität auf die Fragmentinstanz zuzugreifen. // Index - Index des Fragments, dessen Instanz Sie möchten.

Zum Beispiel greife ich auf die Fragmentinstanz von 1 index- zu.

Fragment fragment = (Fragment) viewPageradapter.instantiateItem(viewPager, 1);

if (fragment != null && fragment instanceof MyFragment) {      
 ((MyFragment) fragment).callYourFunction();

}

Ich hatte das gleiche Problem und löste es mit diesem Code.

MyFragment fragment = (MyFragment) thisActivity.getFragmentManager().findFragmentById(R.id.container);

Ersetzen Sie einfach den Namen MyFragment durch den Namen Ihres Fragments und fügen Sie die ID Ihres Fragmentcontainers hinzu.

Dies ist zukunftssicherer als die akzeptierte Antwort:

public class MyFragmentPagerAdapter extends FragmentPagerAdapter {

    /* ------------------------------------------------------------------------------------------ */
    // region Private attributes :

    private Context _context;
    private FragmentManager _fragmentManager;
    private Map<Integer, String> _fragmentsTags = new HashMap<>();

    // endregion
    /* ------------------------------------------------------------------------------------------ */



    /* ------------------------------------------------------------------------------------------ */
    // region Constructor :

    public MyFragmentPagerAdapter(Context context, FragmentManager fragmentManager) {

        super(fragmentManager);

        _context = context;
        _fragmentManager = fragmentManager;
    }

    // endregion
    /* ------------------------------------------------------------------------------------------ */



    /* ------------------------------------------------------------------------------------------ */
    // region FragmentPagerAdapter methods :

    @Override
    public int getCount() { return 2; }

    @Override
    public Fragment getItem(int position) {

        if(_fragmentsTags.containsKey(position)) {

            return _fragmentManager.findFragmentByTag(_fragmentsTags.get(position));
        }
        else {

            switch (position) {

                case 0 : { return Fragment.instantiate(_context, Tab1Fragment.class.getName()); }
                case 1 : { return Fragment.instantiate(_context, Tab2Fragment.class.getName()); }
            }
        }

        return null;
    }

    @Override
    public Object instantiateItem(ViewGroup container, int position) {

        // Instantiate the fragment and get its tag :
        Fragment result = (Fragment) super.instantiateItem(container, position);
        _fragmentsTags.put(position, result.getTag());

        return result;
    }

    // endregion
    /* ------------------------------------------------------------------------------------------ */
}

Das fragliche Szenario wird besser bedient, wenn jedes Fragment seine eigenen Menüelemente hinzufügt und onOptionsItemSelected () direkt verarbeitet, wie in der offiziellen Dokumentation beschrieben . Es ist besser, undokumentierte Tricks zu vermeiden.

Nachdem ich alle Kommentare und Antworten gelesen habe, erkläre ich eine optimale Lösung für dieses Problem. Die beste Option ist @ riks Lösung, daher basiert meine Verbesserung auf seiner.

Anstatt jede FragmentClass wie fragen zu müssen

if(FragmentClass1){
   ...
if(FragmentClass2){
   ...
}

Erstellen Sie Ihre eigene Benutzeroberfläche, und lassen Sie Ihre Kinderfragmente sie implementieren

public interface MyChildFragment {
    void updateView(int position);
}

Dann können Sie so etwas tun, um Ihre inneren Fragmente zu initiieren und zu aktualisieren.

Fragment childFragment = (Fragment) mViewPagerDetailsAdapter.instantiateItem(mViewPager,mViewPager.getCurrentItem());

if (childFragment != null) {
   ((MyChildFragment) childFragment).updateView();
}

PS Seien Sie vorsichtig, wo Sie diesen Code ablegen. Wenn Sie insatiateItem aufrufen, bevor das System ihn tatsächlich erstellt, ist das savedInstanceStateIhres untergeordneten Fragments dafür null

public void onCreate(@Nullable Bundle savedInstanceState){
      super(savedInstanceState)
}

Stürzt Ihre App ab.

Viel Glück

Basierend auf dem, was er @chahat jain geantwortet hat:

"Wenn wir den viewPager verwenden, ist instantiateItem (viewpager, index) eine gute Möglichkeit, auf die Fragmentinstanz in Aktivität zuzugreifen. // Indexindex des Fragments, dessen Instanz Sie möchten."

Wenn du das in Kotlin machen willst

val fragment =  mv_viewpager.adapter!!.instantiateItem(mv_viewpager, 0) as Fragment
                if ( fragment is YourFragmentFragment)
                 {
                    //DO somthign 
                 }

0 auf die Fragmentinstanz von 0

// ================================================ ========================= // // ###################### ######### Anwendungsbeispiel ################################## // // == ================================================== ===================== //

Hier ist ein vollständiges Beispiel, um eine verlustreichste Vision zu erhalten

Hier ist mein veiewPager in der XML-Datei

   ...
    <android.support.v4.view.ViewPager
                android:id="@+id/mv_viewpager"
                android:layout_width="match_parent"
                android:layout_height="match_parent"
                android:layout_margin="5dp"/>
    ...

Und die Heimaktivität, bei der ich die Registerkarte einfüge

...
import kotlinx.android.synthetic.main.movie_tab.*

class HomeActivity : AppCompatActivity() {

    lateinit var  adapter:HomeTabPagerAdapter

    override fun onCreate(savedInstanceState: Bundle?) {
       ...
    }



    override fun onCreateOptionsMenu(menu: Menu) :Boolean{
            ...

        mSearchView.setOnQueryTextListener(object : SearchView.OnQueryTextListener {
          ...

            override fun onQueryTextChange(newText: String): Boolean {

                if (mv_viewpager.currentItem  ==0)
                {
                    val fragment =  mv_viewpager.adapter!!.instantiateItem(mv_viewpager, 0) as Fragment
                    if ( fragment is ListMoviesFragment)
                        fragment.onQueryTextChange(newText)
                }
                else
                {
                    val fragment =  mv_viewpager.adapter!!.instantiateItem(mv_viewpager, 1) as Fragment
                    if ( fragment is ListShowFragment)
                        fragment.onQueryTextChange(newText)
                }
                return true
            }
        })
        return super.onCreateOptionsMenu(menu)
    }
        ...

}

In meiner vorherigen Implementierung habe ich eine Liste untergeordneter Fragmente gespeichert, um später darauf zugreifen zu können. Dies stellte sich jedoch als falsche Implementierung heraus, die zu großen Speicherverlusten führte.

Am Ende benutze ich die instantiateItem(...)Methode, um das aktuelle Fragment zu erhalten:

val currentFragment = adapter?.instantiateItem(viewPager, viewPager.currentItem)

Oder um ein anderes Fragment in Position zu bringen:

val position = 0
val myFirstFragment: MyFragment? = (adapter?.instantiateItem(viewPager, position) as? MyFragment)

Aus der Dokumentation :

Erstellen Sie die Seite für die angegebene Position. Der Adapter ist für das Hinzufügen der Ansicht zu dem hier angegebenen Container verantwortlich, muss jedoch nur sicherstellen, dass dies zum Zeitpunkt der Rückkehr von finishUpdate (ViewGroup) erfolgt.

In meiner Tätigkeit habe ich:

int currentPage = 0;//start at the first tab
private SparseArray<Fragment> fragments;//list off fragments
viewPager.setOnPageChangeListener(new OnPageChangeListener() {

@Override
public void onPageSelected(int pos) {
        currentPage = pos;//update current page
}

@Override
public void onPageScrolled(int arg0, float arg1, int arg2) {}
@Override
public void onPageScrollStateChanged(int arg0) {}
});



@Override
public void onAttachFragment(Fragment fragment) {
    super.onAttachFragment(fragment);
    if(fragment instanceof Fragment1)
        fragments.put(0, fragment);
    if(fragment instanceof Fragment2)
        fragments.put(2, fragment);
    if(fragment instanceof Fragment3)
        fragments.put(3, fragment);
    if(fragment instanceof Fragment4)
        fragments.put(4, fragment);
}

Then I have the following method for getting the current fragment

public Fragment getCurrentFragment() {
    return fragments.get(currentPage);
}

final ViewPager.OnPageChangeListener onPageChangeListener =
    new ViewPager.OnPageChangeListener() {
      @Override public void onPageSelected(int position) {
        switch (position) {
          case 0:
            FragmentClass1 frag1 =
                (FragmentClass1) viewPager.getAdapter()
                    .instantiateItem(viewPager, viewPager.getCurrentItem());
            frag1.updateList("Custom text");
            break;
          case 1:
            break;
          case 2:
            break;
        }
      }

      @Override
      public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {

      }

      @Override public void onPageScrollStateChanged(int state) {
      }
    };


 viewPager.addOnPageChangeListener(onPageChangeListener);

viewPager.setAdapter(adapter);


viewPager.post(new Runnable() {
  @Override public void run() {
    onPageChangeListener.onPageSelected(viewPager.getCurrentItem());
  }
});

Manchmal kann das Fragment ein Nullobjekt auslösen, sodass Sie eine neue ausführbare Datei ausführen können, um das Problem beim ersten Laden zu beheben.

Danke Rick

Überschreiben Sie setPrimaryItem aus Ihrem FragmentPagerAdapter: Das Objekt ist das sichtbare Fragment:

 @Override
        public void setPrimaryItem(ViewGroup container, int position, Object object) {
            if (mCurrentFragment != object) {
                mCurrentFragment = (LeggiCapitoloFragment) object;
            }
            super.setPrimaryItem(container, position, object);
        }

Holen Sie sich einfach den aktuellen Artikel vom Pager und fragen Sie Ihren Adapter nach dem Fragment dieser Position.

 int currentItem = viewPager.getCurrentItem();
    Fragment item = mPagerAdapter.getItem(currentItem);
    if (null != item && item.isVisible()) {
       //do whatever want to do with fragment after doing type checking
        return;
    }

Um das aktuelle Fragment abzurufen , rufen Sie die Position in ViewPager bei public void onPageSelected (endgültige int-Position) ab und dann

public PlaceholderFragment getFragmentByPosition(Integer pos){
    for(Fragment f:getChildFragmentManager().getFragments()){
        if(f.getId()==R.viewpager && f.getArguments().getInt("SECTNUM") - 1 == pos) {
            return (PlaceholderFragment) f;
        }
    }
    return null;
}

SECTNUM - Positionsargument, das im öffentlichen statischen PlaceholderFragment newInstance (int sectionNumber) zugewiesen wurde; des Fragments

getChildFragmentManager () oder getFragmentManager () - hängt davon ab, wie SectionsPagerAdapter erstellt wurde

Sie können einen BroadcastReceiver im Fragment implementieren und eine Absicht von überall senden. Der Empfänger des Fragments kann auf die bestimmte Aktion warten und die Methode der Instanz aufrufen.

Eine Einschränkung besteht darin, sicherzustellen, dass die View-Komponente bereits instanziiert ist und (und für einige Vorgänge, z. B. das Scrollen einer Liste, muss die ListView bereits gerendert sein).

Dies ist der einfachste Hack:

fun getCurrentFragment(): Fragment? {
    return if (count == 0) null
    else instantiateItem(view_pager, view_pager.currentItem) as? Fragment
}

(Kotlin-Code)

Rufen instantiateItem(viewPager, viewPager.getCurrentItem()Sie einfach an und sprechen Sie es an Fragment. Ihr Artikel wurde bereits instanziiert. Um sicherzugehen, können Sie einen Scheck für hinzufügen getCount.

Funktioniert mit beiden FragmentPagerAdapterund FragmentStatePagerAdapter!

Wenn sich Ihr Pager in einem Fragment befindet, verwenden Sie Folgendes:

private fun getPagerCurrentFragment(): Fragment? {
    return childFragmentManager.findFragmentByTag("android:switcher:${R.id.myViewPagerId}:${myViewPager.currentItem}")
}

Wo R.id.myViewPagerIdbefindet sich die ID Ihres ViewPagers im XML-Layout?

Sie können ein Array von Fragmenten als Registerfragmente deklarieren

class DashboardPagerAdapter(fm: FragmentManager?) : FragmentStatePagerAdapter(fm!!) {
    // CURRENT FRAGMENT
    val registeredFragments = SparseArray<Fragment>()

    override fun instantiateItem(container: ViewGroup, position: Int): Any {
        val fragment = super.instantiateItem(container, position) as Fragment
        registeredFragments.put(position, fragment)
        return fragment
    }

    override fun getItem(position: Int): Fragment {
        return when (position) {
            0 -> HomeFragment.newInstance()
            1 -> ConverterDashboardFragment.newInstance()
            2 -> CartFragment.newInstance()
            3 -> CustomerSupportFragment.newInstance()
            4 -> ProfileFragment.newInstance()
            else -> ProfileFragment.newInstance()
        }
    }

    override fun getCount(): Int {
        return 5
    }

}

Dann können Sie es als verwenden

adapter?.let {
    val cartFragment = it.registeredFragments[2] as CartFragment?
    cartFragment?.myCartApi(true)
}