Dissecting-LifeCycle-In-Android

A repository dedicated to logging and understanding the lifecycle of activities, fragments and both of them combined. This can be referred for revision purpose before interviews. README contains good QnA for interviews

Lifecycle callbacks of activities when launching new activity from another

and when back button is pressed from new activity

Lifecycle callbacks of activity when screen is rotated

When device home button is pressed

When User returns back to app from recents tab

Task Modes in Android

standard --|--
singleTop --|--
singleTask --||--
singleInstance --||--
singleInstancePerTask --||--

1. standard

Creates and launches new instance of the activity every time.

2. singleTop

If an instance of the activity already exists at the top of the current task and the system routes the intent to this activity, no new instance will be created because it will fire off an onNewIntent() method instead of creating a new object. If there is no instance of this at the top then it relaunches the activity.

TaskAffinity - Preference of the activity regarding with which task it will associate itself. Basically the task in which they will be launched. By default all activities have the same affinity. Hence they belong to the same task. This affinity is package affinity, basically package name. To change taskAffinity for an activity we specify the android:taskAffinity="some random name". This enables us to switch between different tasks of the same application from recents tab of device.

3. singleTask

with taskAffinity - if we launch our activity with a task affinity then it will open up in new task. Any activity launched by this activity will be kept in its task as it shares the affinity of the root activity In a nutshell, it means that singleTask activity will always be at the root of task. there will be only one instance of activity across tasks. Also in the recents tab, we will see 2 tasks of same application.
without taskAffinity - if there is no instance of activity in the task then a new instance is created and launched. But if its there then it will simply intercept the intent via onNewIntentn() method. If there are some actvities stacked on top of singleTask activity and it is launched again then all above activities gets popped off the task. Also if there's no affinity then it isn't necessary that it will be present at the root of the task

4. singleInstance

with taskAffinity - new activity is launched in a new task. if new activities are launched from this activity then those activities will be launched in original task. Also this activity will be the only activity instance in the new task Also in the recents tab, we will see 2 tasks of same application.
without taskAffinity - new activity is launched in a new task. if new activities are launched from this activity then those activities will be launched in original task. Also this activity will be the only activity instance in the new task. Also in the recents tab, we will see only 1 task of same application.

Fragment Transaction actions

Intro - Committing fragment transaction via commit() after onSaveInstanceState() will throw IllegalStateException.

commit() -

Asynchronous Schedules a commit of this transaction. The commit does not happen immediately; it will be scheduled as work on the main thread to be done the next time that thread is ready. A transaction can only be committed with this method prior to its containing activity saving its state. If the commit is attempted after that point, an exception will be thrown. This is because the state after the commit can be lost if the activity needs to be restored from its state.

commitNow()

Synchronous cant add fragment to backstack with this method. However it immediately schedules the work by placing it at the front of the queue. Transactions committed in this way may not be added to the FragmentManager's back stack,as doing so would break other expected ordering guarantees for other asynchronously committed transactions. cant add fragment to backstack with this method. However it immediately schedules the work by placing it at the front of the queue.

commitAllowingStateLoss()

Asynchronous Schedules a commit of this transaction. The commit does not happen immediately; it will be scheduled as work on the main thread to be done the next time that thread is ready. A transaction can be committed with this method after its containing activity saving its state. If the commit is attempted after that point it wont be saved to fragment manager so state would be lost. So whether it is adding/removing/replacing fragment it wont happen take place.

commitNowAllowingStateLoss()

Synchronous Like commitNow but allows the commit to be executed after an activity's state is saved. Remaining is similar to commitAllowinfStateLoss()

Difference between commitNow() vs commit() followed by executePendingTransactions()

Calling commitNow is preferable to calling commit() followed by FragmentManager.executePendingTransactions() as the latter will have the side effect of attempting to commit all currently pending transactions

Fragments

Note - Create new fragment transaction every time before adding/replacing fragment otherwise while committing on an already committed transaction will throw commint Already called on transaction exception. This is because each transaction can be committed only once

When fragment is added due to any action

Context value is the activity object context which is printed in onAttach

When more fragments are added on top of existing fragment.

Note how the lifecycle of previously added fragment is not affected when new fragments are ADDED

User navigating away from screen which contained fragment and then returning back (Single Fragment) (With or without backstack same result)

User navigating away from screen which contained fragment and then returning back (Mutiple Fragment) (With or without backstack same result)

Fragment popped from backstack

Difference between add and replace transactions https://stackoverflow.com/questions/18634207/difference-between-add-replace-and-addtobackstack

First fragment added without backstack. Second fragment added via replace method but without backstack

Note - See how onDestroyView(), onDestroy() and OnDetach() method of Fragment1 is also called.

First fragment added without backstack. Second fragment added via replace method with backstack

Note - See how onDestroyView() method of Fragment1 is also called.

When back button is pressed(just from above state)

2 fragments(Fragment 1 and Fragment2) added without backstack. Third fragment added via replace method but without backstack

Also Observe the LIFO order pausing of previously added fragments.

2 fragments(Fragment 1 and Fragment2) added without backstack. Third fragment added via replace method with backstack

Note - See how onDestroyView() method of Fragment1 is also called. Also Observe the LIFO order pausing of previously added fragments.

When back button is pressed(just from above state)

Note - Also Observe the FIFO order resuming of previously added fragments. understand that fragment 1 was added before fragment 2. and then replace with backstack with 3rd fragment and then back press on third fragment.

Very Very Important -

When there are multiple fragments added on a screen then if device home button is pressed
or the user returns to the screen from recents tab of device
or if user goes to new activity
or returns back from another activity ............. Then the fragment lifecycle will be
Then the framgent lifecycle callback methods are called in FIFO order that the order in which they were added on screen. Example - Fragment1 added , Fragment2 added, Fragment3 added then their lifecycle methods will be called IN THAT ORDER.

Logs for point 1

Logs for point 2

Logs for point 3

Logs for point 4

2 fragments(Fragment 1 and Fragment2) added with backstack. Third fragment added via replace method with or without backstack <--- both will produce same results

Also Observe the LIFO order pausing of previously added fragments. And also that only the views were destroyed of previous fragments no fragments instance. pressing back button on third fragment will cause LIFO order callbacks for fragment 1 and 2

Back pressed from above state