Getting the current Fragment instance in the viewpager

Below is my code which has 3 Fragment classes each embedded with each of the 3 tabs on ViewPager. I have a menu option. As shown in the onOptionsItemSelected(), by selecting an option, I need to update the fragment that is currently visible. To update that I have to call a method which is in the fragment class. Can someone please suggest how to call that method?

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

Suppose below is the fragment class with the method updateList() I want to call:

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

> by selecting an option, I need to update the fragment that is > currently visible.

A simple way of doing this is using a trick related to the FragmentPagerAdapter implementation:

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;

Please rethink your variable naming convention, using as the variable name the name of the class is very confusing(so no ViewPager ViewPager, use ViewPager mPager for example).

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

First of all keep track of all the "active" fragment pages. In this case, you keep track of the fragment pages in the FragmentStatePagerAdapter, which is used by the ViewPager.

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

To avoid keeping a reference to "inactive" fragment pages, you need to implement the FragmentStatePagerAdapter's destroyItem(...) method:

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

and when you need to access the currently visible page, you then call:

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

Where the MyAdapter's getFragment(int) method looks like this:

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

Hope it may help!

This is the only way I don't get NullPointerException for the instance variables of that particular fragment classes. This might be helpful for others who stuck at the same thing. In the onOptionsItemSelected(), I coded the below way:

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 has public method with the name instantiateItem that return your fragment based on specified parameter values, this method has two parameters ViewGroup (ViewPager) and position.

public Object instantiateItem(ViewGroup container, int position);

Used this method to get specified position's fragment,

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

I know its too late but I have really simple ways of doing it,

// for fragment at 0 possition

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

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

Cast the instance retreived from above line to the fragment you want to work on with. Works perfectly fine.

viewPager

is the pager instance managing the fragments.

There are a lot of answers here that don't really address the basic fact that there's really NO WAY to do this predictably, and in a way that doesn't result you shooting yourself in the foot at some point in the future.

FragmentStatePagerAdapter is the only class that knows how to reliably access the fragments that are tracked by the FragmentManager - any attempt to try and guess the fragment's id or tag is not reliable, long-term. And attempts to track the instances manually will likely not work well when state is saved/restored, because FragmentStatePagerAdapter may well not call the callbacks when it restores the state.

About the only thing that I've been able to make work is copying the code for FragmentStatePagerAdapter and adding a method that returns the fragment, given a position (mFragments.get(pos)). Note that this method assumes that the fragment is actually available (i.e. it was visible at some point).

If you're particularly adventurous, you can use reflection to access the elements of the private mFragments list, but then we're back to square one (the name of the list is not guaranteed to stay the same).

> by selecting an option, I need to update the fragment that is currently visible.

To get a reference to currently visible fragment, assume you have a reference to ViewPager as mPager. Then following steps will get a reference to currentFragment:

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

The only cast used line 3 is valid usually. FragmentStatePagerAdapter is an useful adapter for a ViewPager.

Best way to do this, just call CallingFragmentName fragment = (CallingFragmentName) viewPager .getAdapter() .instantiateItem(viewPager, viewPager.getCurrentItem()); It will re-instantiate your calling Fragment, so that it will not throw null pointer exception and call any method of that fragment.

Current Fragment:

This works if you created a project with the fragments tabbar template.

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

Note that this works with the default tabbed activity template implementation.

I have used the following:

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

When we use the viewPager, a good way to access the fragment instance in activity is instantiateItem(viewpager,index). //index- index of fragment of which you want instance.

for example I am accessing the fragment instance of 1 index-

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

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

}

In my previous implementation I stored a list of child Fragments to be able to access them later, but this turned out to be a wrong implementation causing huge memory leaks.

I end up using instantiateItem(...) method to get current Fragment:

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

Or to get any other Fragment on position:

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

From documentation:

> Create the page for the given position. The adapter is responsible for > adding the view to the container given here, although it only must > ensure this is done by the time it returns from > finishUpdate(ViewGroup).

After reading all comments and answers I am going to explain an optimal solution for this problem. The best option is @rik's solution, so my improvement is based on his.

Instead of having to ask each FragmentClass like

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

Create your own interface, and make your child fragments implement it, something like

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

Then, you can initiate and update your inner fragments with

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

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

P.S. Be careful where you put that code, if you call insatiateItem before the system actually creates it the savedInstanceState of your child fragment will be null therefor

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

Will crash your app.

Good luck

FragmentStatePagerAdapter has a private instance variable called mCurrentPrimaryItem of type Fragment. One can only wonder why Android devs did not supplied it with a getter. This variable is instantiated in setPrimaryItem() method. So, override this method in such a way for you to get the reference to this variable. I simply ended up with declaring my own mCurrentPrimaryItem and copying the contents of setPrimaryItem() to my override.

In your implementation of 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;
}

You can define the PagerAdapter like this then you will able to get any Fragment in 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);
    }
}

To get the current Fragment

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

I had the same issue and solved it using this code.

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

Just replace the name MyFragment with the name of your fragment and add the id of your fragment container.

This is more future-proof than the accepted answer:

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
    /* ------------------------------------------------------------------------------------------ */
}

The scenario in question is better served by each Fragment adding its own menu items and directly handling onOptionsItemSelected(), as described in official documentation. It is better to avoid undocumented tricks.

Based on what he answered @chahat jain :

"When we use the viewPager, a good way to access the fragment instance in activity is instantiateItem(viewpager,index). //index- index of fragment of which you want instance."

If you want to do that in kotlin

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

0 to the fragment instance of 0

//=========================================================================// //#############################Example of uses #################################// //=========================================================================//

Here is a complete example to get a losest vision about

here is my veiewPager in the .xml file

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

And the home activity where i insert the tab

...
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 my Activity I have:

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

Override setPrimaryItem from your FragmentPagerAdapter: the object is the visible fragment:

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

Simply get the current item from pager and then ask your adapter to the fragment of that 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;
    }

To get current fragment - get position in ViewPager at public void onPageSelected(final int position), and then

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 - position argument assigned in public static PlaceholderFragment newInstance(int sectionNumber); of Fragment

getChildFragmentManager() or getFragmentManager() - depends on how created SectionsPagerAdapter

You can implement a BroadcastReceiver in the Fragment and send an Intent from anywhere. The fragment's receiver can listen for the specific action and invoke the instance's method.

One caveat is making sure the View component is already instantiated and (and for some operations, such as scrolling a list, the ListView must already be rendered).

This is the simplest hack:

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

(kotlin code)

Just call instantiateItem(viewPager, viewPager.getCurrentItem() and cast it to Fragment. Your item would already be instantiated. To be sure you can add a check for getCount.

Works with both FragmentPagerAdapter and FragmentStatePagerAdapter!

If your pager is inside a Fragment then use this:

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

Where R.id.myViewPagerId is the id of your ViewPager inside the xml Layout.

You can declare an Array of fragment as register fragments

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
    }

}

Then you can use it as

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

I tried the following:

 int index = mViewPager.getCurrentItem();
 List<Fragment> fragments = getSupportFragmentManager().getFragments();
 View rootView = fragments.get(index).getView();

Because FragmentStateAdapter will add new Fragment to FragmentManager will refer to Fragment in FragmentManager instead of creating new when screen rotates, so you just need to get in FragmentManager good for performance

public MyFragment getActiveFragment() {
        List<Fragment> fragments = getSupportFragmentManager().getFragments();
        for (Fragment fragment : fragments){
            if(fragment instanceof  MyFragment){
                return (MyFragment) fragment;
            }
        }
        return null;
    }