It simply calls a method named onBackPressed , which performs the default behavior of going backwards on the Activity stack. However, if there is an overridden implementation of onBackPressed in the current Activity, that will be executed instead. So to sum up: The hard back button deals with Activities only , which are often "screens" to the user, but aren't necessarily, and are in no way required to be. There is no concept of "go back one screen " unless the app you are using says there is, but that functionality is still not guaranteed to be provided by the back button itself.

If an app doesn't take you to the previous screen when you hit Back, there's nothing you or Android can do about it. You could ask the app's developer to implement it but that's about it. By clicking "Post Your Answer", you acknowledge that you have read our updated terms of service , privacy policy and cookie policy , and that your continued use of the website is subject to these policies. Home Questions Tags Users Unanswered. Navigating Android: Ask Question. This is something of an oversimplification, but the simple answer is: Android applications are based around the concept of an Activity , which is described in the development documentation as: An activity is a single, focused thing that the user can do.

Further reading: Activity and Task Design Activity documentation. Matthew Read Matthew Read 46k 27 Sign up or log in Sign up using Google. Sign up using Facebook. Sign up using Email and Password. Post as a guest Name. Email Required, but never shown. Post Your Answer Discard By clicking "Post Your Answer", you acknowledge that you have read our updated terms of service , privacy policy and cookie policy , and that your continued use of the website is subject to these policies. As such, if Activity A starts Activity B, Activity B can define in its manifest how it should associate with the current task if at all and Activity A can also request how Activity B should associate with current task.

If both activities define how Activity B should associate with a task, then Activity A's request as defined in the intent is honored over Activity B's request as defined in its manifest. Some launch modes available for the manifest file are not available as flags for an intent and, likewise, some launch modes available as flags for an intent cannot be defined in the manifest.

The launchMode attribute specifies an instruction on how the activity should be launched into a task. There are four different launch modes you can assign to the launchMode attribute:. An intent arrives for an activity of type D. However, if D's launch mode is "singleTop" , the existing instance of D receives the intent through onNewIntent , because it's at the top of the stack—the stack remains A-B-C-D. However, if an intent arrives for an activity of type B, then a new instance of B is added to the stack, even if its launch mode is "singleTop". When a new instance of an activity is created, the user can press the Back button to return to the previous activity.

But when an existing instance of an activity handles a new intent, the user cannot press the Back button to return to the state of the activity before the new intent arrived in onNewIntent. Although the activity starts in a new task, the Back button still returns the user to the previous activity. This means that if your app issues an intent to open the Android Browser, its activity is not placed in the same task as your app.

Instead, either a new task starts for the Browser or, if the Browser already has a task running in the background, that task is brought forward to handle the new intent. Regardless of whether an activity starts in a new task or in the same task as the activity that started it, the Back button always takes the user to the previous activity.

However, if you start an activity that specifies the singleTask launch mode, then if an instance of that activity exists in a background task, that whole task is brought to the foreground. At this point, the back stack now includes all activities from the task brought forward, at the top of the stack. Figure 4 illustrates this type of scenario. Figure 4. A representation of how an activity with launch mode "singleTask" is added to the back stack.

If the activity is already a part of a background task with its own back stack, then the entire back stack also comes forward, on top of the current task.

Understand Tasks and Back Stack | Android Developers

The behaviors that you specify for your activity with the launchMode attribute can be overridden by flags included with the intent that start your activity, as discussed in the next section. When starting an activity, you can modify the default association of an activity to its task by including flags in the intent that you deliver to startActivity.

The flags you can use to modify the default behavior are:. This produces the same behavior as the "singleTask" launchMode value, discussed in the previous section.

Providing proper Back navigation

This produces the same behavior as the "singleTop" launchMode value, discussed in the previous section. There is no value for the launchMode attribute that produces this behavior. When used together, these flags are a way of locating an existing activity in another task and putting it in a position where it can respond to the intent. If the launch mode of the designated activity is "standard" , it too is removed from the stack and a new instance is launched in its place to handle the incoming intent.

That's because a new instance is always created for a new intent when the launch mode is "standard". The affinity indicates which task an activity prefers to belong to.

By default, all the activities from the same app have an affinity for each other. So, by default, all activities in the same app prefer to be in the same task. However, you can modify the default affinity for an activity. Activities defined in different apps can share an affinity, or activities defined in the same app can be assigned different task affinities. A new activity is, by default, launched into the task of the activity that called startActivity. It's pushed onto the same back stack as the caller. Often, it's a new task.

However, it doesn't have to be. If there's already an existing task with the same affinity as the new activity, the activity is launched into that task. If not, it begins a new task. If this flag causes an activity to begin a new task and the user presses the Home button to leave it, there must be some way for the user to navigate back to the task.

In this case, the activity can move from the task it starts to the task it has an affinity for, when that task comes to the foreground. For example, suppose that an activity that reports weather conditions in selected cities is defined as part of a travel app. It has the same affinity as other activities in the same app the default app affinity and it allows re-parenting with this attribute.

When one of your activities starts the weather reporter activity, it initially belongs to the same task as your activity. However, when the travel app's task comes to the foreground, the weather reporter activity is reassigned to that task and displayed within it. If an APK file contains more than one "app" from the user's point of view, you probably want to use the taskAffinity attribute to assign different affinities to the activities associated with each "app".

2.1: Understanding Activities and Intents

If the user leaves a task for a long time, the system clears the task of all activities except the root activity. When the user returns to the task again, only the root activity is restored. The system behaves this way, because, after an extended amount of time, users likely have abandoned what they were doing before and are returning to the task to begin something new.

You can set up an activity as the entry point for a task by giving it an intent filter with "android. MAIN" as the specified action and "android. For example:. An intent filter of this kind causes an icon and label for the activity to be displayed in the app launcher, giving users a way to launch the activity and to return to the task that it creates any time after it has been launched. This second ability is important: Users must be able to leave a task and then come back to it later using this activity launcher.

Imagine, for example, what could happen if the filter is missing: An intent launches a "singleTask" activity, initiating a new task, and the user spends some time working in that task. The user then presses the Home button. The task is now sent to the background and is not visible. Now the user has no way to return to the task, because it is not represented in the app launcher.

Further information about how tasks and activities are represented and managed in the Overview screen is available in Recents Screen. Content and code samples on this page are subject to the licenses described in the Content License. App Basics. Build your first app. App resources. Resource types. App manifest file. App permissions.

Device compatibility. Multiple APK support. Adding wearable features to notifications. Creating wearable apps. Creating custom UIs.

Sending and syncing data. Creating data providers. Creating watch faces. Android TV. Building TV Apps. Building TV playback apps. Helping users find content on TV. Recommending TV content. Building TV channels. Android Auto. Android Things. Developer kits. Advanced setup. Build apps. Create a Things app. Communicate with wireless devices. Configure devices.

OUR LEARNERS WORK AT

Interact with peripherals. Build user-space drivers. Manage devices. Create a build. Push an update. Chrome OS devices. Core topics. Interact with other apps. Handling app links. App shortcuts. App widgets. Architecture Components. Data Binding Library. Paging Library. Intents and intent filters. Improving layout performance.

Custom view components. Look and feel. Add the app bar. Control the system UI visibility. Designing effective navigation. Implementing effective navigation. Supporting swipe-to-refresh. Pop-up messages overview. Adding search functionality. Creating backward-compatible UIs.