What is a Task?

A Task is a collection of activities that users interact with as a unit. It defines a "workflow" — a cohesive experience that starts when the user launches an app and ends when they press Back all the way out. Android maintains tasks separately from your app's process.

Think of a Task as a stack of screens. The user always interacts with the screen at the top. When they press Back, the top screen is popped and the one beneath it becomes active. This is the Android back stack.

Tasks vs processes

These are completely independent concepts that developers often confuse:

When the system kills your process to reclaim memory, the Task record survives. When the user taps your app icon again, Android recreates the Activities from the task's record, restoring the back stack using the saved instance state bundles.

The Recents screen

The Recents screen (Overview / App Switcher) shows one card per Task, not per app. An app can have multiple tasks — each gets its own card. This is why opening a document link from Gmail might show two Gmail cards in Recents: one for the main inbox task and one for the document viewer task.

The Back Stack

The back stack is a LIFO (Last In, First Out) stack of Activity instances within a Task. Every time you call startActivity(), a new Activity is pushed onto the stack. Every time the user presses Back (or calls finish()), the top Activity is popped and destroyed.

What happens on Back press

When the user presses Back on the last Activity in a Task (the root Activity), the Task is moved to the background. The process may keep running, but the task is no longer visible. If the user returns via Recents or the launcher icon, the task resumes exactly where they left it — as long as the system hasn't killed the process.

Multiple tasks in the background

Android keeps multiple tasks in memory simultaneously. When you switch apps (via Recents or the launcher), Android brings the selected app's task to the foreground. The previously visible task moves to the background — its Activities go through onPause → onStop but are not destroyed. They're simply hidden, waiting.

Task Affinity

Every Activity has a task affinity — a string identifier for which task it "prefers" to belong to. By default, all Activities in an app share the same affinity: the app's package name. This means they naturally live in the same task.

Task affinity only matters in two specific situations: when an Activity is launched with FLAG_ACTIVITY_NEW_TASK, or when an Activity has allowTaskReparenting="true".

<!-- Default: affinity = package name -->
<activity android:name=".MainActivity" />

<!-- Custom affinity — prefers a different task -->
<activity
    android:name=".DocumentActivity"
    android:taskAffinity="com.myapp.documents"
    android:launchMode="singleTask" />

<!-- No affinity — never shares a task -->
<activity
    android:name=".IsolatedActivity"
    android:taskAffinity="" />

allowTaskReparenting

When set to true, an Activity can move between tasks. If Activity C (with affinity "com.other") was started by your app and placed in your task, the next time "com.other" is brought to the foreground, Activity C will reparent — it migrates from your task to the "com.other" task automatically. This is how Android handles email links to other apps.

standard

The default. Every call to startActivity() creates a brand new instance of the Activity and pushes it onto the current task's back stack — regardless of whether an instance already exists anywhere in the stack.

singleTop

If an instance of the Activity is already at the top of the back stack, Android reuses it instead of creating a new one. It calls onNewIntent(intent) on the existing instance. If the Activity is not at the top (even if it exists elsewhere in the stack), a new instance is created normally.

// AndroidManifest.xml
// android:launchMode="singleTop"

class NotificationActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        handleIntent(intent)   // handle initial launch
    }

    override fun onNewIntent(intent: Intent) {
        super.onNewIntent(intent)
        setIntent(intent)       // update getIntent() for future calls
        handleIntent(intent)   // same handler — no duplicated logic
    }

    private fun handleIntent(intent: Intent) {
        val notifId = intent.getStringExtra("notif_id") ?: return
        viewModel.loadNotification(notifId)
    }
}

singleTask

The most powerful and most misunderstood launch mode. The system ensures only one instance exists across the entire task. When the Activity is launched:

If an instance already exists anywhere in its task → the system brings that task to the foreground, clears everything above it in the stack, and calls onNewIntent(). If no instance exists → creates a new one (potentially in a new task if the affinity differs).

singleInstance

The most isolated mode. The Activity gets its own private task — no other Activity can ever be added to that task. It is the only Activity in its task, always. Any Activity launched from a singleInstance Activity goes into a different task.

When re-launched: the existing instance is reused and onNewIntent() is called, exactly like singleTask. But unlike singleTask, there's nothing above it to clear — it's always alone.

Intent Flags

Intent flags give you per-launch control over how an Activity is placed on the back stack — without changing the manifest. They override or augment the declared launch mode for a single call. They're especially important for notification deep links, shortcuts, and cross-app launches.

// From a Service or BroadcastReceiver
val intent = Intent(this, MainActivity::class.java).apply {
    flags = Intent.FLAG_ACTIVITY_NEW_TASK
}
startActivity(intent)

// Navigate "home" clearing all screens above
val intent = Intent(this, HomeActivity::class.java).apply {
    flags = Intent.FLAG_ACTIVITY_CLEAR_TOP or
            Intent.FLAG_ACTIVITY_SINGLE_TOP
}
startActivity(intent)

fun logout() {
    authManager.signOut()
    val intent = Intent(this, LoginActivity::class.java).apply {
        flags = Intent.FLAG_ACTIVITY_NEW_TASK or
                Intent.FLAG_ACTIVITY_CLEAR_TASK
    }
    startActivity(intent)  // all activities destroyed, LoginActivity fresh
}

Launch Mode Playground

Select a launch mode, then tap activities to push them onto the stack. See exactly how each mode affects the back stack in real time.

Real-world Scenarios

Knowing the theory is one thing. Here's how launch modes and flags map to actual product requirements:

intent.flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK

val stackBuilder = TaskStackBuilder.create(this)
stackBuilder.addParentStack(ProductDetailActivity::class.java)
stackBuilder.addNextIntent(Intent(this, ProductDetailActivity::class.java).apply {
    putExtra("product_id", productId)
})
val pendingIntent = stackBuilder.getPendingIntent(0, PendingIntent.FLAG_UPDATE_CURRENT)