Parameter Passing from Notification Clicks to Activities in Android: A Comprehensive Implementation Guide

Core Mechanism Analysis of Notification Parameter Passing

In Android development, passing parameters to target Activities through notification click events is a common but error-prone functional requirement. The core of the issue lies in understanding the encapsulation mechanism of PendingIntent and the interaction with Activity launch modes. While the original questioner's code correctly used the putExtra() method, it overlooked the reuse characteristics of PendingIntent, causing the same Intent object to be returned with each notification click.

Correct Configuration of PendingIntent

When creating notifications, PendingIntent must be properly configured to ensure parameters are correctly passed. Key steps include:

// Create an Intent object containing parameters
Intent notificationIntent = new Intent(context, MainActivity.class);
notificationIntent.putExtra("item_id", "1001");

// Use FLAG_UPDATE_CURRENT to ensure parameter updates
PendingIntent contentIntent = PendingIntent.getActivity(
    context, 
    0, 
    notificationIntent, 
    PendingIntent.FLAG_UPDATE_CURRENT
);

// Attach PendingIntent to the notification
notif.contentIntent = contentIntent;

The key here is the use of the PendingIntent.FLAG_UPDATE_CURRENT flag. Without this flag, the system reuses previously created PendingIntents, preventing new parameters from taking effect. This mechanism explains why the questioner's extras were always null—the system returned the initially created Intent object rather than an updated version with new parameters.

Activity Launch Modes and Parameter Reception

When the target Activity might already be running, special handling is required to correctly receive new parameters. There are two equivalent implementation approaches:

Approach 1: Control via Intent Flags

// Add flags when creating the Intent
notificationIntent.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);

Approach 2: Configuration via Manifest File

<activity
    android:name=".MainActivity"
    android:launchMode="singleTop" />

Both approaches ensure that when the Activity is already at the top of the stack, no new instance is created; instead, the new Intent is delivered via the onNewIntent() method. This is crucial for solving the "onCreate runs only once" problem.

Parameter Handling Logic in Activities

In the Activity, both initial launch and subsequent updates need to be handled:

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);
    
    // Handle parameters during initial launch
    processIntent(getIntent());
}

@Override
protected void onNewIntent(Intent intent) {
    super.onNewIntent(intent);
    
    // Handle parameters during subsequent updates
    setIntent(intent); // Update current Intent reference
    processIntent(intent);
}

private void processIntent(Intent intent) {
    Bundle extras = intent.getExtras();
    if (extras != null && extras.containsKey("item_id")) {
        String itemId = extras.getString("item_id");
        Log.i("Notification", "Received item_id: " + itemId);
        // Update UI or perform other operations based on item_id
        updateUIWithItem(itemId);
    }
}

Key points here include: 1) Calling setIntent() in onNewIntent() to update the Activity's current Intent reference; 2) Extracting parameter processing logic into a separate method for multiple calls; 3) Using containsKey() for safe parameter checking.

Advanced Handling for Multiple Notification Scenarios

When an application needs to display multiple independent notifications, each notification requires a unique identifier to prevent parameter confusion. Drawing from the practical experience in the second answer:

// Use a unique requestCode for each notification
int notificationIndex = generateUniqueId();
PendingIntent pendingIntent = PendingIntent.getActivity(
    getApplicationContext(),
    notificationIndex, // Unique identifier
    notificationIntent,
    PendingIntent.FLAG_UPDATE_CURRENT
);

By setting different requestCodes for each PendingIntent, the system can distinguish between notification instances, ensuring correct parameters are passed when different notifications are clicked. This is particularly important in messaging applications where users might receive multiple message notifications simultaneously.

Complete Implementation Example and Best Practices

Synthesizing the above analysis, a complete implementation of notification parameter passing should include the following elements:

1. Use PendingIntent.FLAG_UPDATE_CURRENT to ensure parameter updates
2. Configure FLAG_ACTIVITY_SINGLE_TOP or singleTop launch mode
3. Correctly implement the onNewIntent() method in the Activity
4. Use unique requestCodes for multiple notification scenarios
5. Add appropriate error handling and logging

Below is a complete server-side notification creation example:

public class DownloadService extends Service {
    private void createDownloadCompleteNotification(String itemId) {
        // Build notification content
        NotificationCompat.Builder builder = new NotificationCompat.Builder(this, CHANNEL_ID)
            .setSmallIcon(R.drawable.ic_download_complete)
            .setContentTitle("Download Complete")
            .setContentText("Tap to view details")
            .setPriority(NotificationCompat.PRIORITY_DEFAULT)
            .setAutoCancel(true);
        
        // Create Intent with parameters
        Intent intent = new Intent(this, ItemDetailActivity.class);
        intent.putExtra("item_id", itemId);
        intent.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP | Intent.FLAG_ACTIVITY_CLEAR_TOP);
        
        // Create PendingIntent
        PendingIntent pendingIntent = PendingIntent.getActivity(
            this,
            generateNotificationId(itemId), // Generate unique ID based on itemId
            intent,
            PendingIntent.FLAG_UPDATE_CURRENT
        );
        
        builder.setContentIntent(pendingIntent);
        
        // Display notification
        NotificationManagerCompat.from(this).notify(NOTIFICATION_ID, builder.build());
    }
    
    private int generateNotificationId(String itemId) {
        // Simple implementation for generating unique IDs
        return itemId.hashCode();
    }
}

Through this implementation approach, developers can ensure: 1) Correct parameters are passed with each notification click; 2) Parameters are properly handled regardless of the Activity's state; 3) No parameter conflicts occur between multiple notifications. These practices are essential for building robust Android notification systems.