Android get fragment from viewpager

How to get Fragment from ViewPager Android

How to get Fragment from ViewPager Android

In this tutorial i will show you that how to get fragment from ViewPager inside activity or fragment.

So main focus of this tutorial is that if you have ViewPager in your activity and you want to access particular method from fragment of ViewPager. Directly its impossible, because we don’t have direct reference to fragments of ViewPager in parent class.

Why we need to access ViewPager’s fragment from Activity ?

Suppose you have 1 button on your Activity class and you want to use that single button to call method of every fragments of ViewPager. Then you can’t access those method on you Activity class.

How to get Fragment from ViewPager in Activity/Fragment ?

ViewPager save Fragment in FragmentManager with particular tags, So We can get ViewPager’s fragment by FragmentManager class by providing tag. And ViewPager provide tag to each fragment by following syntax :

above is the code to get Fragment from ViewPager.

in this code ‘R.id.viewpager’ is real id of your ViewPager. and ‘viewPager.getCurrentItem()’ method will return currently selected fragment in ViewPager. You can also provide specific position of fragment if you want to access only 1 fragment. for example:

this code will get access to first fragment of ViewPager. and then you can type cast that Fragment into your Fragment. for example

if above given solution not work for you then you can also try this method.

in this example ‘myPagerAdapter’ is your ViewPager’s Adapter.

and then you can access public methods and variables of that fragment in your activity class.

Full example:

code of my Activity which is having ViewPager.

Источник

Android Fragments Common Queries & Common Mistakes

Fragment class in Android is used to build dynamic User Interfaces. Fragment should be used within the Activity. A greatest advantage of fragments is that it simplifies the task of creating UI for multiple screen sizes. A activity can contain any number of fragments.

Now this meaning of fragment sounds good and easy, right? But there is lot more involved, this article covers main needs and common mistakes while using Fragments.

I am assuming you are having basic knowledge of Fragment and Fragment lifecycle callbacks also I am assuming you know how implement communication between two fragments this article goes beyond that

So here are a few obstacles related to fragments some of you must have faced already, some of you might face later.

• FragmentManager: getSupportFragmentManager and getChildFragmentManager. Which one to use when and avoid memory leaks while using them.
• Callback from DialogFragment, ChildFragment, BottomSheetFragment to parent fragment.
• Fragments when using ViewPager and when to use FragmentStateAdapter vs FragmentPagerAdapter.
• When to use FragmentTransaction add vs replace ?
• Fragment receivers, broadcasts and memory leaks.
• Fragment BottomBarNavigation and drawer. How to handle these?
• commit() and commitAllowingStateLoss()
• Fragment option menus.
• Fragment getActivity(), getView() and NullPointers Exceptions.
• onActivityResult with nested fragments.
• Fragment and Bundle.
• Back Navigation.

Whoa . see its a big list, reply in comment if anyone wish to add something more to the list.

getSupportFragmentManager and getChildFragmentManager

FragmentManager is class provided by the framework which is used to create transactions for adding, removing or replacing fragments.

• getSupportFragmentManager is associated with Activity consider it as a FragmentManager for your Activity .

So whenever you are using ViewPager, BottomSheetFragment and DialogFragment in an Activity you will use getSupportFragmentManager

• getChildFragmentManager is associated with fragment.

Whenever you are ViewPager inside Fragment you will use getChildFragmentManager

Here is official link for this for better understanding.

Now coming to common mistakes people do when they are using ViewPager inside a Fragment they pass getSupportFragmentManager which is fragment manager for Activity and it causes issues as such memory leaks, ViewPager not updated properly sometimes etc.

Most important issue caused by using getSupportFragmentManager in Fragment is memory leak, let me tell you how? Your Fragment has stack of fragments which is used by ViewPager or any other thing and all these fragments stack is in activity since you used getSupportFragmentManager , now if close your Parent fragment it will be closed but it will not be destroyed because all child Fragments are in activity and they are still in memory which does not allow to destroy Parent Fragment hence causing leak. It will not just leak parent fragment but also leak all child fragments since none of them can be cleared from heap memory. So never try to use getSupportFragmentManager in a Fragment

Callback from DialogFragment, ChildFragment, BottomSheetFragment to parent fragment

This is very common issue people face when they use BottomSheetFragment or DialogFragment or ChildFragment.

Add a child fragment

Another example bottomSheetFragment

Now suppose you want callback from these child fragments to parent fragments . Most of people create connection between two fragments using activity, few people pass interface listeners as a parameter to fragment which really a bad practice and one should avoid this. Best way calling getParentFragment() from your child fragment to create a call back this is very simple way consider example below.

then setting callback to parent fragment add following code in child fragment.

thats it you can give a callback to your parent fragment now easily.

Using same way you can create a callback from child fragment inside ViewPager to parent fragment who is holding ViewPager.

Fragments when using ViewPager and adapters FragmentStateAdapter and FragmentPagerAdapter which one one to use when

FragmentPagerAdapter stores the whole fragment in memory, and could increase a memory overhead if a large amount of fragments are used in ViewPager . FragmentStatePagerAdapter only stores the savedInstanceState of fragments, and destroys all the fragments when they lose focus.

So when your is going to have many Fragments use FragmentStateAdapter if ViewPager is going to have less than three fragments use FragmentPagerAdapter.

Commonly faced issues

Update ViewPager not working:

People always come across the issue remember ViewPager fragments are managed by FragmentManager either from Fragment or Activity and this FragmentManager holds instance of all ViewPager Fragments.

So when people say ViewPager is not refreshed it’s nothing but old instances of fragments are still being hold by FragmentManager. So you need to find out why FragmentManger is holding instance of Fragments is there any leak or not ideally to refresh ViewPager following code works if it is not you are doing something wrong

Access current Fragment from ViewPager:

This is also very common issue we come across. For this people either create array list of fragments inside adapter or try to access fragment using some tags according to me both methods are not reliable. FragmentStateAdapter and FragmentPagerAdapter both provides method setPrimaryItem this can be used to set current fragment as below.

I am leaving a Github link below to this simple ViewPager project so that everyone can understand better.

amodkanthe/ViewPagerTest

Contribute to amodkanthe/ViewPagerTest development by creating an account on GitHub.

FragmentTransaction add vs replace

In our Activity we have a container and inside this container we display our Fragments

add will simply add fragment to container suppose you add FragmentA and FragmentB to container. Container will have FragmentA and FragmentB both and suppose if container is FrameLayout fragments are added one above the other. replace will simply replace a fragment on top of container so if I call create FragmentC now and call replace FragmentB which was on top will removed from container unless you are not calling addToBackStack and now FragmentC will be on top.

So which one to use when. replace removes the existing fragment and adds a new fragment . This means when you press back button the fragment that got replaced will be created with its onCreateView being invoked. Whereas add retains the existing fragments and adds a new fragment that means existing fragment will be active and they wont be in ‘paused’ state hence when a back button is pressed onCreateView is not called for the existing fragment(the fragment which was there before new fragment was added). In terms of fragment’s life cycle events onPause, onResume, onCreateView and other life cycle events will be invoked in case of replace but they wont be invoked in case of add .

Use replace fragment if don’t need to revisit current fragment and current fragment is not require anymore. Also if your app has memory constraints use replace instead of add.

Fragment receivers, broadcasts and memory leaks

Mistakes people commonly do when using receivers inside a fragment forgot to unregister receiver in onPause or OnDestroy. If you are registering fragment to listen to receiver inside onCreate or OnResume you will have to unregister it inside onPause or onDestroy otherwise it will cause memory leak

Also if have multiple fragments listening to same broadcast receiver make sure you register in onResume and unregister in onPause. Because if you use onCreate and onDestroy for register and unregister other fragments will not receive the broadcast as this fragment is not destroyed

Fragment BottomBarNavigation and drawer how to handle these

When we are using BottomBarNavigation and NavigationDrawer people face issues like fragments recreated, same fragment is added multiple times etc.

So in such case you can use fragment transaction show and hide instead of add or replace.

There is also one beautiful library which take care of navigations and avoid recreation of fragments called FragNav below is link to it

Источник

ViewPager2 with Fragments Android Example

In this post, I’ll learn viewpager2 with fragments implementation in Android. ViewPager2 is an optimized version of ViewPager. In the previous article, I was explained the implementation of ViewPager2 with TabLayout Android.

Internally ViewPager2 uses RecyclerView component to display swipeable content. ViewPager2 have so many new features, In this android example post, we’ll learn ViewPager2 implementation with Fragments.

Steps of Implementation ViewPager2 with Fragments

• Create a project with androidx
• Add the ViewPager2 dependencies
• Update some resource file, that needed for this demo
• Create fragments for ViewPager2
• Create a subclass of FragmentStateAdapter
• Add the ViewPager in activity layout
• Finally set the FragmentStateAdapter on ViewPager

1. Create a project with Androidx

Let’s open the Android Studio to create a project with AndroidX.

2. Add the ViewPager2 dependencies

Open the app-level build. gradle file and add below dependencies

3. Update some resource file

Add few color items in color.xml files

4. Create fragments for ViewPager2

Simply creates a fragment named is CardFragment with XML layout. Open the layout file paste below code.

Bind above fragment layout with file

Let’s paste below code in the CardFragment.java file. In this fragment have a TextView

5. Create a subclass of FragmentStateAdapter

6. Add the ViewPager in activity layout

7. Finally set the FragmentStateAdapter on ViewPager

Conclusion

In this android app example, we have learned the implementation of ViewPager2 with Fragment in Android. I hope it’s helpful for you.

Keep in touch

If you want to keep in touch and get an email when I write new blog posts, follow me on facebook or subscribe to us. It only takes about 10 seconds to register.

Источник

ViewPager Using Fragments in Android with Example

ViewPager is a layout manager that allows the user to flip left and right through pages of data. It is mostly found in apps like Youtube, Snapchat where the user shifts right – left to switch to a screen. Instead of using activities fragments are used. It is also used to guide the user through the app when the user launches the app for the first time.

ViewPager Using Fragments in Android

Steps for implementing viewpager:

1. Adding the ViewPager widget to the XML layout (usually the main_layout).
2. Creating an Adapter by extending the FragmentPagerAdapter or FragmentStatePagerAdapter class.

An adapter populates the pages inside the Viewpager. PagerAdapter is the base class which is extended by FragmentPagerAdapter and FragmentStatePagerAdapter. Let’s see a quick difference between the two classes.

Difference between FragmentPagerAdapter and FragmentStatePagerAdapter:

Following is the structure of the ViewPagerAdapter Class:

Method Description:

• getCount(): This method returns the number of fragments to display. (Required to Override)
• getItem(int pos): Returns the fragment at the pos index. (Required to override)
• ViewPagerAdapter(@NonNull FragmentManager FM): (required) The ViewPager Adapter needs to have a parameterized constructor that accepts the FragmentManager instance. Which is responsible for managing the fragments. A FragmentManager manages Fragments in Android, specifically, it handles transactions between fragments. A transaction is a way to add, replace, or remove fragments.
• getPageTitle(int pos): (optional) Similar to getItem() this methods returns the title of the page at index pos.
• add(Fragment fragment, String title): This method is responsible for populating the fragments and fragmentTitle lists. which hold the fragments and titles respectively.

Example

A sample GIF is given below to get an idea about what we are going to do in this article. Note that we are going to implement this project using the Java language.

Step by Step Implementation

Step 1: Create a New Project

To create a new project in Android Studio please refer to How to Create/Start a New Project in Android Studio. Note that select Java as the programming language. Initially, the project directory should look like this.

Step 2: Working with the activity_main.xml file

The three widgets AppBarLayout used to host the TabLayout which is responsible for displaying the page titles. ViewPager layout which will house the different fragments. The below Image explains the important parameters to set to get the app working as intended.

Источник