Hey there, let's figure out why your current approach isn't working reliably and fix it. The problem with using a Handler in onStop() is that it's tightly tied to your Activity's lifecycle and the app's process—once your app goes to the background, Android might throttle background tasks, kill your process to free up memory, or your Activity could be recreated, making that delayed finish() call never execute.

Why Your Original Code Fails #

Let's break down the core issues:

• Process/Activity Recycling: If Android kills your app's process while it's in the background, your Handler and Runnable are gone entirely. When the user returns, the system recreates Activity B, so the delayed finish never happens.
• Background Task Throttling: Android restricts background work (especially on newer API levels) to save battery. Your main thread's Looper might not process the delayed runnable on time, or at all.
• No Cleanup on Resume: If the user returns to the app before the 1 minute is up, your Runnable is still queued up—meaning Activity B will suddenly finish even while the user is using it, which is a terrible UX.

Solution 1: Use WorkManager (Most Reliable) #

WorkManager is built specifically for background tasks that need to run even if the app is killed or the device restarts. Here's how to implement it:

1. Add WorkManager Dependency (if you don't have it already):

   implementation "androidx.work:work-runtime:2.8.1"
   

2. Create a Worker Class to trigger the finish action (we'll use a local broadcast to notify Activity B):

   public class CloseActivityWorker extends Worker {
       public static final String ACTION_CLOSE_B = "com.yourpackage.action.CLOSE_ACTIVITY_B";
   
       public CloseActivityWorker(@NonNull Context context, @NonNull WorkerParameters params) {
           super(context, params);
       }
   
       @NonNull
       @Override
       public Result doWork() {
           // Send a local broadcast to tell Activity B to finish
           Intent intent = new Intent(ACTION_CLOSE_B);
           LocalBroadcastManager.getInstance(getApplicationContext()).sendBroadcast(intent);
           return Result.success();
       }
   }
   

3. Modify Activity B to schedule/cancel work and listen for the broadcast:

   public class ActivityB extends AppCompatActivity {
       private WorkRequest mCloseWorkRequest;
       private BroadcastReceiver mCloseReceiver;
   
       @Override
       protected void onCreate(Bundle savedInstanceState) {
           super.onCreate(savedInstanceState);
           setContentView(R.layout.activity_b);
   
           // Initialize broadcast receiver to listen for finish signal
           mCloseReceiver = new BroadcastReceiver() {
               @Override
               public void onReceive(Context context, Intent intent) {
                   if (CloseActivityWorker.ACTION_CLOSE_B.equals(intent.getAction())) {
                       finish();
                   }
               }
           };
           LocalBroadcastManager.getInstance(this)
               .registerReceiver(mCloseReceiver, new IntentFilter(CloseActivityWorker.ACTION_CLOSE_B));
       }
   
       @Override
       protected void onStop() {
           super.onStop();
           // Schedule a 1-minute delayed work request
           mCloseWorkRequest = new OneTimeWorkRequest.Builder(CloseActivityWorker.class)
               .setInitialDelay(1, TimeUnit.MINUTES)
               .build();
           WorkManager.getInstance(this).enqueue(mCloseWorkRequest);
       }
   
       @Override
       protected void onResume() {
           super.onResume();
           // Cancel the work if user returns before the 1-minute mark
           if (mCloseWorkRequest != null) {
               WorkManager.getInstance(this).cancelWorkById(mCloseWorkRequest.getId());
           }
       }
   
       @Override
       protected void onDestroy() {
           super.onDestroy();
           // Unregister broadcast receiver to avoid memory leaks
           LocalBroadcastManager.getInstance(this).unregisterReceiver(mCloseReceiver);
       }
   }
   

Solution 2: Use AlarmManager (For Precise Short Delays) #

If you need a more precise delay (though WorkManager is still preferred for background reliability), you can use AlarmManager:

1. Modify Activity B to set/cancel alarms:

   public class ActivityB extends AppCompatActivity {
       private static final int REQUEST_CODE_CLOSE_B = 1001;
       private PendingIntent mClosePendingIntent;
   
       @Override
       protected void onCreate(Bundle savedInstanceState) {
           super.onCreate(savedInstanceState);
           setContentView(R.layout.activity_b);
   
           // Create PendingIntent to trigger our broadcast receiver
           Intent intent = new Intent(this, CloseActivityReceiver.class);
           mClosePendingIntent = PendingIntent.getBroadcast(this, REQUEST_CODE_CLOSE_B, intent, PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_IMMUTABLE);
       }
   
       @Override
       protected void onStop() {
           super.onStop();
           // Set alarm to trigger after 1 minute
           AlarmManager alarmManager = (AlarmManager) getSystemService(Context.ALARM_SERVICE);
           long triggerTime = System.currentTimeMillis() + 60 * 1000;
           if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
               // Use setExactAndAllowWhileIdle to bypass doze mode
               alarmManager.setExactAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, triggerTime, mClosePendingIntent);
           } else {
               alarmManager.setExact(AlarmManager.RTC_WAKEUP, triggerTime, mClosePendingIntent);
           }
       }
   
       @Override
       protected void onResume() {
           super.onResume();
           // Cancel alarm if user returns early
           AlarmManager alarmManager = (AlarmManager) getSystemService(Context.ALARM_SERVICE);
           alarmManager.cancel(mClosePendingIntent);
       }
   
       // Broadcast Receiver to finish Activity B
       public static class CloseActivityReceiver extends BroadcastReceiver {
           @Override
           public void onReceive(Context context, Intent intent) {
               // Check if Activity B is running and finish it on the main thread
               new Handler(Looper.getMainLooper()).post(() -> {
                   if (context instanceof Activity) {
                       ((Activity) context).finish();
                   }
               });
           }
       }
   }
   

2. Register the Receiver in your AndroidManifest.xml:

   <receiver
       android:name=".ActivityB$CloseActivityReceiver"
       android:exported="false" />
   

Key Takeaways #

• Always Cancel Delayed Tasks on Resume: This ensures the user doesn't get interrupted mid-use.
• Choose WorkManager for Background Reliability: It automatically handles doze mode, app standby, and process death—something Handler can't do.

内容的提问来源于stack exchange，提问作者porlicus