Same Activity Appears Again on Backpress in Android

When doing a task, users engage with a chore, which is a set of actions. The activities are stacked in the gild in which they are opened in a stack chosen the dorsum stack. I action in an e-mail app, for example, maybe to display a list of fresh messages. When the user picks a message, a new activeness appears in which the user may read the message. This new action has been sent to the back of the queue. When the user clicks the Back button, the new action is completed and removed from the stack. When numerous applications are running in a multi-windowed surround, which is allowed in Android 7.0 (API level 24) and above, the organization maintains tasks for each window individually; each window may contain several tasks. The organisation organizes tasks, or groups of tasks, on a per-window basis for Android apps running on Chromebooks.

Figure i. Understanding the Dorsum Stack

For most tasks, the device'due south Abode screen is the starting point. The piece of work of an app is brought to the front when the user taps an icon in the app launcher (or a shortcut on the Home screen). If no job for the app exists (because it hasn't been used recently), a new chore is created, and the app's "main" action is opened as the stack'southward root activity.

When the electric current activity switches to a new 1, the new activity is pushed to the top of the stack and takes control of the attention. The preceding action is notwithstanding there in the stack, but it is no longer active. When a task is completed, the organisation saves the current state of the user interface. The current action is plucked off the summit of the stack (the activity is destroyed) when the user hits the Dorsum button, and the prior activity restarts (the previous state of its UI is restored). The activities in the stack are only pushed onto and popped off the stack—pushed into the stack when the current activity starts information technology and popped off when the user exits it using the Dorsum button. As a consequence, the back stack is an object construction that is "terminal in, first out." Figure 1 depicts this behavior using a timeline that shows the progression of activities as well as the electric current back stack at each point in fourth dimension.

What Happens on Back Press?

If the user presses Back repeatedly, each activity in the stack is popped off to testify the one before information technology, until the user returns to the Dwelling house screen (or to whichever activity was running when the task began). The chore is no longer active after all deportment have been removed from the stack.

Figure 2. Losing Focus

A task is a logical unit that may exist sent to the "groundwork" when users start a new job or press the Home button to return to the Home screen. All operations in the task are paused while information technology is in the background, only the chore's back stack remains intact—the task has only lost focus while another task is being performed, as seen in figure 2. A task can then be brought back into the "foreground," allowing users to resume their piece of work where they left off. Assume that the current task (Task A) contains three activities in its stack, two of which are underneath the electric current activity. The user hits the Home button, and then opens the app launcher and selects a new app. Task A is pushed to the groundwork when the Abode screen appears. When a new app is launched, the organisation creates a job (Chore B) for it, which has its own set of activities. After interacting with that app, the user goes back to Habitation and picks the app that launched Job A in the beginning identify. Task A now appears in the forefront, with all three activities in its stack intact and the activity at the height of the stack resumed. The user may at present render to Chore B past navigating to Habitation and choosing the app icon that initiated the task (or choosing the app's task from the Recents page). On Android, this is an case of multitasking.

Because the activities in the back stack are never reorganized if your app allows users to launch a specific activity from multiple activities, a new example of that activity is produced and placed onto the stack (rather than bringing whatever previous instance of the activity to the top). As a result, a single action in your app may exist invoked many times (even from distinct jobs). As a outcome, if the user uses the Back push to browse backward, each instance of the activity will be presented in the sequence in which information technology was accessed (each with its ain UI land). If you don't want an activeness to be created more than in one case, still, you may modify this behavior. In the department on Managing Tasks, we'll become through how to accomplish that. To describe the default behavior for activities and tasks, consider the following:

• Activity A is interrupted when Activeness B begins, but the organization'southward state is preserved (such as scroll position and text entered into forms). When the user returns to Activity A after pressing the Back button in Activity B, the state of Activity A is restored.
• When a user exits a chore by hitting the Home button, the present activeness is terminated and the chore is placed in the groundwork. Every action in the task is saved in the organization's memory. The task comes to the foreground and resumes the activity at the top of the stack if the user subsequently continues it by clicking the launcher icon that started it in the get-go place.
• The electric current activity is removed from the stack and deleted when the user hits the Back button. In the stack, the prior action is resumed. The organisation does not keep runway of the status of activity when it is deleted.

Even from other tasks, activities tin be instantiated several times.

Organizing Your Tasks

For nearly apps, the way Android manages tasks and the back stack (by placing all activities initiated in sequence in the same task and in a "last in, first out" stack) works fine, and you lot shouldn't have to worry about how your activities are continued with tasks or how they appear in the back stack. You may, nevertheless, determine that you want to deviate from the standard. Mayhap you desire an activity in your app to commencement a new task (rather than existence placed within the electric current job), or possibly you desire to bring an existing instance of activity forward (rather than creating a new instance on top of the back stack) when the user leaves the task, or possibly yous desire your back stack to be cleared of all activities except the root action when the user leaves the chore. With characteristics in the activity> manifest element and flags in the intent that you send to startActivity, you can perform all of these things and more than.

The following tags can be used for defining the Dorsum Stack forcefully:

• taskAffinity
• launchMode
• allowTaskReparenting
• clearTaskOnLaunch
• alwaysRetainTaskState
• finishOnTaskLaunch

XML

< activity

android:proper name = ".GeeksforGeeks"

android:launchMode = "singleTop" />

GeekTip: When it comes to activities and tasks, nigh apps should not interfere with the usual behavior. If yous decide that changing the default behaviors is important for your activity, continue with circumspection and brand sure to evaluate the usability of the action during launch and while returning to information technology using the Back button from other activities and tasks. Be careful to check for navigational behaviors that are inconsistent with the user'due south expectations.

Few Fundamental Characteristics of a Task

When a new task is created or the Habitation button is clicked, information technology disappears into the groundwork. The job is then brought to the front end past clicking the launcher icon (this is the other function of the launcher icon that we discussed before) or selecting it from the contempo screens. When many tasks are running in the background or the user exits a Task for an extended period of time, the organization clears the task of all activities except the root Activity in order to free up memory. Only the root Activity is restored when the user returns to the Job once more

A Quick Shot Instance

The Android Browser application specifies that the web browser activeness should always be launched in its own Task . This implies that if your app sends out an intent to launch the Android browser, that activity isn't assigned to the same task as your app. Instead, a new job is started for the Browser, or an existing task is moved forrard to fulfill the new intent if the Browser currently has one running in the background.

How to add Different launchModes using Java:

Java

Intent openIntent = new Intent(getApplicationContext(), GeeksforGeeksActivity. class );

openIntent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK | Intent.FLAG_ACTIVITY_NEW_TASK);

getApplicationContext().startActivity(openIntent);

And that'southward it!
That'south how you master the deed of Backstack and Tasks!

craigdisteling49.blogspot.com

Source: https://www.geeksforgeeks.org/task-and-back-stack-in-android/

Share this post