In-depth Analysis of Android Activity Closing and Returning Mechanisms: From Task Stack to Lifecycle Management

Problem Scenario Analysis

In Android application development, navigation between Activities is fundamental yet crucial functionality. Developers often encounter a typical issue: after starting a new Activity from the main Activity, calling the finish() method in the new Activity not only closes the current Activity but unexpectedly causes the entire application to exit, including the destruction of the main Activity.

Core Problem Diagnosis

Based on the problem description and best answer analysis, this situation is typically caused by the following two reasons:

Reason One: MainActivity has android:noHistory attribute set

The MainActivity has android:noHistory = "true" set in the AndroidManifest.xml. This configuration causes MainActivity to automatically finish after starting a new Activity, no longer remaining in the task stack. When users press the back button or call finish() in the new Activity, since there are no other Activities in the task stack, the system returns directly to the home screen.

Reason Two: Improper finish() call in MainActivity

The finish() method is called in MainActivity before starting SettingsActivity. This immediately terminates MainActivity's lifecycle, removing it from the task stack. When SettingsActivity needs to return, there are no available Activities in the task stack, causing the complete application exit.

Deep Analysis of Android Task Stack Mechanism

The Android system manages Activity navigation relationships through the task stack (Back Stack). The task stack follows the Last-In-First-Out (LIFO) principle, with newly started Activities pushed to the top of the stack, gaining focus and user interaction permissions.

When Activity A starts Activity B, the system performs the following operations:

// Typical code for Activity A starting Activity B
Intent intent = new Intent(ActivityA.this, ActivityB.class);
startActivity(intent);

At this point, the task stack state becomes: ActivityA (stopped state) → ActivityB (running state). Although ActivityA is stopped, the system preserves its UI state, including scroll position, form input, and other data.

Correct Activity Closing and Return Implementation

To properly implement Activity closing and return functionality, the integrity of the task stack must be ensured:

Solution One: Check and correct AndroidManifest configuration

Ensure MainActivity does not have the android:noHistory attribute set, or set it to false:

<activity
    android:name=".MainActivity"
    android:label="@string/app_name"
    android:noHistory="false">
    <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.LAUNCHER" />
    </intent-filter>
</activity>

Solution Two: Correct Activity startup logic

Ensure that when starting a new Activity, do not prematurely call the current Activity's finish() method:

// Correct startup approach
public void openSettingsActivity() {
    Intent intent = new Intent(this, SettingsActivity.class);
    startActivity(intent);
    // Do not call finish() here
}

// Return handling in SettingsActivity
public void onBackButtonClick() {
    finish(); // Only close current Activity, return to MainActivity
}

Activity Launch Modes and Task Management

The Android system provides multiple launch modes to control Activity instance creation and task stack behavior:

standard mode (default)

Creates a new Activity instance each time it's started, suitable for most scenarios. Example code:

// Standard launch mode, creates new instance each time
Intent intent = new Intent(this, DetailActivity.class);
startActivity(intent);

singleTop mode

Reuses the existing instance if the target Activity is already at the top of the stack, avoiding duplicate creation:

// Configure in manifest
<activity
    android:name=".NotificationActivity"
    android:launchMode="singleTop" />

Back Button Behavior and System Version Compatibility

Different Android versions handle the Back button differently, requiring special attention:

Android 11 and lower versions

Pressing the Back button in the root launcher Activity causes the system to finish that Activity.

Android 12 and higher versions

The system moves the Activity and its task to the background instead of finishing the Activity. This provides faster application recovery experience.

It's recommended to use AndroidX Activity API to handle back navigation instead of overriding onBackPressed():

// Using AndroidX for back navigation handling
public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        
        // Set up back callback
        getOnBackPressedDispatcher().addCallback(this, new OnBackPressedCallback(true) {
            @Override
            public void handleOnBackPressed() {
                // Custom back logic
                if (shouldCustomHandleBack()) {
                    handleCustomBack();
                } else {
                    setEnabled(false);
                    getOnBackPressedDispatcher().onBackPressed();
                }
            }
        });
    }
}

Task Stack State Preservation and Restoration

The Android system automatically manages the state of Activities in the task stack:

When an Activity enters the stopped state, the system preserves its UI state. When the Activity regains focus, the system restores these states. This mechanism ensures smooth user experience during navigation between Activities.

Developers can manage additional state data through onSaveInstanceState() and onRestoreInstanceState() methods:

@Override
protected void onSaveInstanceState(@NonNull Bundle outState) {
    super.onSaveInstanceState(outState);
    outState.putString("user_input", editText.getText().toString());
}

@Override
protected void onRestoreInstanceState(@NonNull Bundle savedInstanceState) {
    super.onRestoreInstanceState(savedInstanceState);
    String savedText = savedInstanceState.getString("user_input");
    editText.setText(savedText);
}

Best Practices Summary

Based on problem analysis and Android official documentation, the following best practices are summarized:

1. Properly configure Activity attributes

Avoid unnecessary android:noHistory settings to ensure task stack integrity.

2. Correctly use finish() method

Call finish() only when certain to end the current Activity, not before starting a new Activity.

3. Follow system navigation standards

Use AndroidX Activity API for back navigation handling to ensure consistency with system behavior.

4. Consider multi-version compatibility

Handle Back button behavior differences appropriately across different Android versions.

5. Maintain clear task stack

Use launch modes and Intent flags reasonably to avoid creating complex task stack structures.

By deeply understanding Android task stack mechanisms and Activity lifecycle, developers can build more stable and user-friendly application navigation experiences. Properly managing Activity startup, closing, and return processes is a key factor in ensuring application quality and user experience.