Mechanisms and Practices for Finishing and Restarting Activities Across Activities in Android

Introduction

In Android app development, Activity is the fundamental unit of the user interface, and managing its lifecycle is a core challenge. Developers often encounter scenarios where they need to control the finishing and restarting of one Activity from another, such as in multi-step forms or complex navigation flows. This article builds on a typical Stack Overflow question: starting Activity B from Activity A, then dynamically finishing and restarting Activity A based on user actions in Activity B (e.g., clicking "New" or "Modify" buttons). We will analyze several solutions in depth and provide detailed code implementations with explanations.

Problem Background and Core Requirements

Assume two Activities: Activity A and Activity B. In Activity A, Activity B is launched via a button click without finishing Activity A, to preserve its state. In Activity B, there are two buttons: "New" and "Modify". When the user clicks "Modify", Activity A should be popped (possibly with pre-selected options); when clicking "New", Activity A needs to be finished and removed from the stack, then reloaded as a new instance. The original code attempted to use startActivityForResult and onActivityResult but failed to finish Activity A, causing stack management issues.

Solution 1: Using Static Activity Reference (Primary Reference from Answer 1)

This is the most straightforward method, by declaring a static Activity object in Activity A and calling its finish() method in Activity B. First, initialize the static reference in Activity A's onCreate method:

public class FirstActivity extends Activity {
    public static Activity fa;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        fa = this;
        // Other initialization code
    }
}

In Activity B, when the user clicks the "New" button, finish Activity A as follows:

public class SecondActivity extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // Assume in a button click event
        if (FirstActivity.fa != null) {
            FirstActivity.fa.finish();
        }
        // Then launch a new Activity A
        Intent intent = new Intent(this, FirstActivity.class);
        startActivity(intent);
    }
}

This method is simple and effective, but note the risk of memory leaks: static references may prevent Activity A from being garbage-collected, especially during configuration changes (e.g., screen rotation). It is recommended to nullify the reference in Activity A's onDestroy: fa = null;. Additionally, combining launchMode = "singleInstance" (set in AndroidManifest.xml) ensures Activity A is unique in the stack, avoiding conflicts with multiple instances.

Solution 2: Using Intent Flags (Supplementary Reference from Answer 1)

Another approach is to add Intent flags when launching Activity B to control Activity A's behavior. For example, using Intent.FLAG_ACTIVITY_NO_HISTORY:

Intent GotoB = new Intent(A.this, B.class);
GotoB.addFlags(Intent.FLAG_ACTIVITY_NO_HISTORY);
startActivityForResult(GotoB, 1);

This flag causes Activity A to be removed from the history stack immediately after launching Activity B, but it can be too aggressive: even if the user clicks "Modify", Activity A will be finished and must be restarted via Intent. Thus, it is more suitable for simple scenarios and not for cases where Activity A's state needs preservation. Developers should balance its convenience with flexibility.

Solution 3: Using Broadcast Receivers (Reference from Answer 2)

Broadcast receivers offer a loosely coupled way, allowing Activity B to send a broadcast signal, which Activity A receives and finishes itself. First, register a broadcast receiver in Activity A:

public class FirstActivity extends Activity {
    private BroadcastReceiver broadcastReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            if ("finish_activity".equals(intent.getAction())) {
                finish(); // Finish Activity A
                // Optionally restart Activity A
                Intent newIntent = new Intent(FirstActivity.this, FirstActivity.class);
                startActivity(newIntent);
            }
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        registerReceiver(broadcastReceiver, new IntentFilter("finish_activity"));
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        unregisterReceiver(broadcastReceiver); // Avoid memory leaks
    }
}

In Activity B, send the broadcast:

Intent intent = new Intent("finish_activity");
sendBroadcast(intent);

This method decouples direct dependencies between Activities but adds complexity and requires careful registration and unregistration to avoid resource leaks. It is suitable for distributed or event-driven architectures.

Comparative Analysis and Best Practices

Summarizing the above solutions, the static reference method is most direct for simple apps but requires careful lifecycle management; the Intent flag method is lightweight but less flexible; the broadcast receiver method is highly decoupled but has higher overhead. In practice, it is recommended to:

1. Prioritize using static references with launchMode optimization, ensuring cleanup in onDestroy.
2. For complex navigation, combine startActivityForResult with custom result codes, handling finishing logic in onActivityResult, but avoid errors like misuse of overridePendingTransition as in the original problem.
3. Avoid overusing broadcasts unless the app architecture is event-driven.

Additionally, Android officially recommends using ViewModel and LiveData for UI state management to reduce direct Activity manipulation, but in cross-Activity control scenarios, the methods discussed remain practical.

Conclusion

Finishing and restarting Activities across Activities is a common requirement in Android development. This article provides a path from simple to complex implementations by analyzing multiple technical solutions. The core lies in understanding Activity lifecycle and stack management, choosing methods suited to the app's context. Developers should balance performance, maintainability, and user experience, applying these techniques flexibly to build robust Android apps. As Android architecture components become more prevalent, more state management solutions may simplify such tasks, but the foundational principles remain essential.