20

FragmentActivity.onResume() javadoc:

Dispatch onResume() to fragments. Note that for better inter-operation with older versions of the platform, at the point of this call the fragments attached to the activity are not resumed. This means that in some cases the previous state may still be saved, not allowing fragment transactions that modify the state. To correctly interact with fragments in their proper state, you should instead override onResumeFragments().

FragmentActivity.onResumeFragments() javadoc:

This is the fragment-orientated version of onResume() that you can override to perform operations in the Activity at the same point where its fragments are resumed. Be sure to always call through to the super-class.

Does the above mean that the platform guarantees that:

  • fragments are never going to be resumed (their onResume() not called) while executing FragmentActivity.onResume() and
  • fragments are always going to be resumed (their onResume() called) while executing FragmentActivity.onResumeFragments()?

If not, how can a developer correctly utilize and be vigilant regarding the above?

nekojsi
  • 1,423
  • 2
  • 13
  • 28
  • I have found out that performing a fragment transaction inside `onResume()` after instance state has been saved causes _IllegalStateException: Can not perform this action after onSaveInstanceState_ while performing it inside `onResumeFragments()` doesn't. Then I noticed the documentation for `FragmentActivity.onResume()` says exactly that. – Piovezan May 29 '15 at 14:11

1 Answers1

18

Will onResume() be called?

Yes, FragmentActivity.onResume() will still be called (same context as Activity.onResume()). Even if you override FragmentActivity.onResumeFragments() (additional method from FragmentActivity that knows it contains Fragments).

What is the difference between onResume() and onResumeFragments()?

FragmentActivity.onResumeFragments() is a callback on FragmentActivity as to when the Fragments it contains are resuming, which is not the same as when the Activity resumes.

This is the fragment-orientated version of onResume() that you can override to perform operations in the Activity at the same point where its fragments are resumed. Be sure to always call through to the super-class.

When to use which method?

If you are using the support-v4 library and FragmentActivity, try to always use onResumeFragments() instead of onResume() in your FragmentActivity implementations.

FragmentActivity#onResume() documentation:

To correctly interact with fragments in their proper state, you should instead override onResumeFragments().

Difference is subtle, see https://github.com/xxv/android-lifecycle/issues/8:

onResume() should be used for normal Activity's and onResumeFragments() when using the v4 compat library. This is only required when the application is waiting for the initial FragmentTransaction's to be completed by the FragmentManager.

shkschneider
  • 17,833
  • 13
  • 59
  • 112
  • 1
    From what I can see in the source, `onResume()` has an override in `FragmentActivity`, so it is not the same version of the `Activity` one. However, I have also noticed in `FragmentActvity`'s source that `onResumeFragments()` is called from `onPostResume()`, so it is at least certain that it is called after `onResume()`. Ideally, I would accept an answer that specifies when to use `onResumeFragments()` as opposed to `onResume()`, or confirms my assumption. – nekojsi Dec 24 '14 at 15:11
  • 1
    You're right. To put it simple: if you are using support-v4 library, try to always use `onResumeFragments()` instead of `onResume()`. Difference is subtle, see https://github.com/xxv/android-lifecycle/issues/8 – shkschneider Jan 06 '15 at 14:18
  • Thanks. Could you update the answer (the link is especially useful), so I can accept it? – nekojsi Jan 08 '15 at 13:47