This happens when Android’s FragmentManager is unable to instantiate the current fragment as it couldn’t find an empty fragment constructor.

Well, how does one end up here?

For the most part, we can have a code like this and get away with a functioning application that is unless our app goes through a process-death or configuration change and Android starts recreating everything.

Looking at the fixes

There are two ways to go about addressing this issue and let’s look at each of them.

1. Fragment Factory

Here we create a FragmentFactory with the same arguments that we passed to the fragment’s constructor and delegate the responsibility of instantiating the fragment to the factory.

We then assign this factory to the parent activity’s (or fragment) fragmentManager in theonCreate function before super.onCreate(..) call.

Now the FragmentManager uses this factory to recreate our fragment whenever necessary.

Our above code will look like this

We can further tidy things up a bit by creating a lazy extension function.

Now we can change lateinit var mainFragment to 
val mainFragment by fragmentFromFactory<MainFactory>() and remove mainFragment instantiation from onCreate()

If we were using a DI library in our project then we can further reduce the boilerplate of creating factories and let the library handle that for us using constructor injection.

Using Koin library as an example our activity code will look like this

and we let Koin know of our fragment’s dependency by adding a module to it

Detailed implementation for Koin can be found here. Something similar can be achieved using multibindings in Dagger, refer to this blog

Well, if everything looks good so far so then why will we require another way of solving the same issue?

The limitation of using FragmentFactory is that we can’t pass dynamic arguments to it.¹

Let’s say we have a ViewPager that display’s two instances of the same mainFragment but with different textToDisplay values then this won’t be possible using the fragmentFactory implementation.

In that case, we need to provide bundle arguments to the fragment instead

2. Bundle arguments

There is nothing new in this, this is how most of us have been using fragments from the get-go.

What we can do though is create some extension functions to make it a little less awful to work with.

We can now create a fragment instance like this

val mainFragment = MainFragment().withArgs { 
  putString(MainFragment.KEY_TEXT, "Now this won't crash")
}

and inside the fragment, we can get the argument value like this

private val textToDisplay by argument<String>(KEY_TEXT)

Duplication Issue
One problem with creating fragments ourselves without first checking if the fragment exists is that we might end up having duplicate or unattached fragments. This can lead to crashes down the line.

Using fragmentManager.findFragmentByTag(..) we can create another lazy extension to handle that as well.

In this function, we try to find the fragment by atag and if it returns nullwe use the provided lambda to create the actual fragment.

All we need to do now is check if the fragment is already added before adding it to the fragment manager and our final code will look like this.

References

[1] https://issuetracker.google.com/issues/136898243#comment24

https://zsmb.co/lets-review-pokedex
https://proandroiddev.com/the-seven-actually-10-cardinal-sins-of-android-development-491d2f64c8e0

https://proandroiddev.com/android-fragments-fragmentfactory-ceec3cf7c959

Thanks to Jibin Lawrance.