react-native-notify-kit 10.9.0 → 10.9.1

package/README.md

@@ -55,6 +55,8 @@ This fork fills the gap: it preserves all of Notifee's advanced features, migrat
 
 The native core (NotifeeCore) is compiled from source as part of the bridge module (since 9.2.0) and the public API is **100% compatible** with the original `@notifee/react-native` — migration is a safe, drop-in replacement.
 
+**10.9.1 Android fixes — [#88](https://github.com/marcocrupi/react-native-notify-kit/issues/88):** `getInitialNotification()` no longer replays consumed identifiable interactions; new interactions, including taps reusing a notification ID, remain available. Supported recovery and native full-screen capture use the [documented one-shot and latest-wins semantics and limits](https://docs.page/marcocrupi/react-native-notify-kit/react-native/events#android-consumption-and-recovery). Related upstream [notifee#880](https://github.com/invertase/notifee/issues/880) is not claimed fully resolved by this qualification.
+
 ## Installation
 
 ```bash

package/android/src/main/AndroidManifest.xml

@@ -12,6 +12,17 @@
   <uses-permission android:name="android.permission.ACCESS_NOTIFICATION_POLICY" android:minSdkVersion="23" />
 
   <application>
+    <!-- Each capture finishes itself; noHistory can cancel a queued launch before onCreate. -->
+    <activity
+      android:name="app.notifee.core.FullScreenNotificationActivity"
+      android:noHistory="false"
+      android:excludeFromRecents="true"
+      android:taskAffinity=""
+      android:theme="@android:style/Theme.NoDisplay"
+      android:showWhenLocked="true"
+      android:turnScreenOn="true"
+      android:exported="false" />
+
     <!-- Receiver Service -->
     <service
       android:name="app.notifee.core.ReceiverService"

package/android/src/main/java/app/notifee/core/EventBus.java

@@ -57,6 +57,10 @@ public class EventBus {
     return getInstance().getDefault().removeStickyEvent(eventType);
   }
 
+  static boolean removeStickyEvent(Object event) {
+    return getInstance().getDefault().removeStickyEvent(event);
+  }
+
   private org.greenrobot.eventbus.EventBus getDefault() {
     return eventBus;
   }

package/android/src/main/java/app/notifee/core/FullScreenNotificationActivity.java

@@ -0,0 +1,76 @@
+package app.notifee.core;
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import android.app.Activity;
+import android.content.Intent;
+import android.os.Bundle;
+import android.view.WindowManager;
+
+/** Captures a full-screen launch before starting its consumer, without displaying a window. */
+public class FullScreenNotificationActivity extends Activity {
+  static final String ACTION = "app.notifee.core.FULL_SCREEN_LAUNCH";
+  static final String LAUNCH_INTENT = "app.notifee.core.FULL_SCREEN_CONSUMER";
+
+  @Override
+  protected void onCreate(Bundle state) {
+    // API 26 uses window flags; newer versions also use the manifest's screen/keyguard flags.
+    getWindow()
+        .addFlags(
+            WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED
+                | WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON);
+    super.onCreate(state);
+    launchConsumer(getIntent());
+  }
+
+  @Override
+  protected void onNewIntent(Intent intent) {
+    super.onNewIntent(intent);
+    launchConsumer(intent);
+  }
+
+  private void launchConsumer(Intent intent) {
+    try {
+      if (intent == null
+          || !ACTION.equals(intent.getAction())
+          || !Notifee.isValidFullScreenLaunch(intent)) return;
+      Intent destination = intent.getParcelableExtra(LAUNCH_INTENT);
+      if (destination == null
+          || destination.getComponent() == null
+          || !getPackageName().equals(destination.getComponent().getPackageName())) return;
+      // An invalid/disabled destination must not retire a previous unread launch.
+      if (getPackageManager().resolveActivity(destination, 0) == null) {
+        return;
+      }
+      // The carrier owns the payload. The nested Intent contains only the original destination
+      // and flags, so the private routing extra never reaches the consumer or the public API.
+      Intent consumer = new Intent(destination);
+      consumer.replaceExtras(new Bundle(intent.getExtras()));
+      consumer.removeExtra(LAUNCH_INTENT);
+      if (ContextHolder.getApplicationContext() == null) {
+        ContextHolder.setApplicationContext(getApplicationContext());
+      }
+      Notifee.recordFullScreenLaunch(consumer);
+      startActivity(consumer);
+    } catch (Exception e) {
+      Logger.e("FullScreenNotificationActivity", "Failed to launch full-screen consumer", e);
+    } finally {
+      finish();
+    }
+  }
+}

package/android/src/main/java/app/notifee/core/InitialNotificationLedger.java

@@ -0,0 +1,262 @@
+package app.notifee.core;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.os.SystemClock;
+import androidx.annotation.Nullable;
+import androidx.annotation.VisibleForTesting;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.UUID;
+
+/**
+ * Durable record of the interactions returned by {@link Notifee#getInitialNotification}, so each
+ * one is returned at most once, also when its Activity is recreated in a new process (#88).
+ *
+ * <p>Taps of {@link NotificationPendingIntent} launch flows are numbered by {@link
+ * NotificationReceiverHandler}. The number travels with the sticky {@code InitialNotificationEvent}
+ * and is stored with the id of the tapped PendingIntent; like the sticky event, only the latest tap
+ * is kept. The sticky event and the launch Intent of a tap claim the same number, so the tap is
+ * returned by whichever is read first. A launch Intent can only claim the latest tap of its own
+ * PendingIntent, which it gets once the sticky event has been lost with the process that received
+ * it.
+ *
+ * <p>Full-screen launches are not numbered: each display issues its own id, recorded as unclaimed
+ * before the notification is posted. A claim removes the id, so an id already returned, or never
+ * issued, is not returned, however many launches follow. Ids issued before the device last rebooted
+ * are dropped when the next id is issued, as no Intent extras survive a reboot. A new delivered
+ * launch retires the previous delivered launch before its in-memory payload is replaced.
+ *
+ * <p>Claims are committed before the interaction is returned.
+ */
+final class InitialNotificationLedger {
+  private static final String TAG = "InitialNotificationLedger";
+  private static final String PREFERENCES_FILE = "app.notifee.core.initial_notification";
+  private static final String LAST_TAP_SEQUENCE_KEY = "last_tap_sequence";
+  private static final String LAST_TAP_PENDING_INTENT_ID_KEY = "last_tap_pending_intent_id";
+  private static final String CLAIMED_TAP_SEQUENCE_KEY = "claimed_tap_sequence";
+  private static final String UNCLAIMED_FULL_SCREEN_IDS_KEY = "unclaimed_full_screen_ids";
+  private static final String LAST_FULL_SCREEN_LAUNCH_ID_KEY = "last_full_screen_launch_id";
+  private static final String FULL_SCREEN_ISSUE_UPTIME_KEY = "full_screen_issue_uptime";
+
+  private static final Object lock = new Object();
+
+  private InitialNotificationLedger() {}
+
+  /**
+   * Records a tap before its sticky event is posted.
+   *
+   * @return the tap's sequence number, or 0 if it was not recorded (the tap is then returned by its
+   *     sticky event only).
+   */
+  static long recordTap(@Nullable String pendingIntentId) {
+    synchronized (lock) {
+      try {
+        SharedPreferences preferences = getPreferences();
+        long sequence = preferences.getLong(LAST_TAP_SEQUENCE_KEY, 0) + 1;
+        // Main thread, so not committed: a record lost with the process only means the tap cannot
+        // be recovered from its launch Intent; it is never returned twice.
+        preferences
+            .edit()
+            .putLong(LAST_TAP_SEQUENCE_KEY, sequence)
+            .putString(LAST_TAP_PENDING_INTENT_ID_KEY, pendingIntentId)
+            .apply();
+        return sequence;
+      } catch (Exception e) {
+        Logger.e(TAG, "Failed to record notification tap", e);
+        return 0;
+      }
+    }
+  }
+
+  enum TapClaim {
+    CLAIMED,
+    ALREADY_CLAIMED,
+    RETRY
+  }
+
+  /** Claims a sticky tap durably, or leaves it pending when storage is unavailable. */
+  static TapClaim claimTap(long tapSequence) {
+    if (tapSequence <= 0) {
+      return TapClaim.CLAIMED;
+    }
+
+    synchronized (lock) {
+      try {
+        SharedPreferences preferences = getPreferences();
+        long claimed = preferences.getLong(CLAIMED_TAP_SEQUENCE_KEY, 0);
+        if (tapSequence <= claimed) {
+          return TapClaim.ALREADY_CLAIMED;
+        }
+        if (preferences.edit().putLong(CLAIMED_TAP_SEQUENCE_KEY, tapSequence).commit()) {
+          return TapClaim.CLAIMED;
+        }
+        // A failed edit still advances the in-memory value. Keep the interaction retryable,
+        // without returning a tap that a later process could return again.
+        preferences.edit().putLong(CLAIMED_TAP_SEQUENCE_KEY, claimed).apply();
+        Logger.w(TAG, "Failed to persist notification tap claim");
+      } catch (Exception e) {
+        Logger.e(TAG, "Failed to claim notification tap", e);
+      }
+      return TapClaim.RETRY;
+    }
+  }
+
+  /** Claims the latest tap for a launch Intent of {@code pendingIntentId}, if not returned yet. */
+  static boolean claimLatestTap(String pendingIntentId) {
+    synchronized (lock) {
+      try {
+        SharedPreferences preferences = getPreferences();
+        long latest = preferences.getLong(LAST_TAP_SEQUENCE_KEY, 0);
+        if (latest <= preferences.getLong(CLAIMED_TAP_SEQUENCE_KEY, 0)
+            || !pendingIntentId.equals(
+                preferences.getString(LAST_TAP_PENDING_INTENT_ID_KEY, null))) {
+          return false;
+        }
+        return claimTap(latest) == TapClaim.CLAIMED;
+      } catch (Exception e) {
+        Logger.e(TAG, "Failed to claim notification tap", e);
+        return false;
+      }
+    }
+  }
+
+  /**
+   * Issues the id of a full-screen launch Intent and records it as unclaimed, before the
+   * notification is posted.
+   *
+   * @return the id; one that could not be recorded is never claimed.
+   */
+  static String issueFullScreenLaunchId() {
+    String id = UUID.randomUUID().toString();
+    synchronized (lock) {
+      try {
+        SharedPreferences preferences = getPreferences();
+        long uptime = SystemClock.elapsedRealtime();
+        Set<String> unclaimed = new HashSet<>();
+        // Uptime restarts at boot: below the uptime of the last issue, every id issued so far
+        // predates a reboot.
+        if (uptime >= preferences.getLong(FULL_SCREEN_ISSUE_UPTIME_KEY, 0)) {
+          unclaimed.addAll(
+              preferences.getStringSet(UNCLAIMED_FULL_SCREEN_IDS_KEY, Collections.emptySet()));
+        }
+        unclaimed.add(id);
+        if (!preferences
+            .edit()
+            .putStringSet(UNCLAIMED_FULL_SCREEN_IDS_KEY, unclaimed)
+            .putLong(FULL_SCREEN_ISSUE_UPTIME_KEY, uptime)
+            .commit()) {
+          // The id is claimable in this process only.
+          Logger.w(TAG, "Failed to persist full-screen launch");
+        }
+      } catch (Exception e) {
+        Logger.e(TAG, "Failed to record full-screen launch", e);
+      }
+    }
+    return id;
+  }
+
+  /**
+   * Records a delivered full-screen launch and retires the previous delivered one. Only ids are
+   * persisted: an earlier Activity creation Intent must stay retired even when this process,
+   * including the payload of the replacement, is lost before the next read. Displayed notifications
+   * that have not launched are left alone.
+   *
+   * @return false for an unknown/claimed id. A failed write keeps the replacement in memory; its
+   *     claim must persist it before returning the interaction.
+   */
+  static boolean recordFullScreenLaunch(String pendingIntentId) {
+    synchronized (lock) {
+      try {
+        SharedPreferences preferences = getPreferences();
+        Set<String> unclaimed =
+            preferences.getStringSet(UNCLAIMED_FULL_SCREEN_IDS_KEY, Collections.emptySet());
+        if (!unclaimed.contains(pendingIntentId)) {
+          return false;
+        }
+        String previousId = preferences.getString(LAST_FULL_SCREEN_LAUNCH_ID_KEY, null);
+        if (pendingIntentId.equals(previousId)) {
+          return true;
+        }
+        Set<String> remaining = new HashSet<>(unclaimed);
+        remaining.remove(previousId);
+        if (preferences
+            .edit()
+            .putStringSet(UNCLAIMED_FULL_SCREEN_IDS_KEY, remaining)
+            .putString(LAST_FULL_SCREEN_LAUNCH_ID_KEY, pendingIntentId)
+            .commit()) {
+          return true;
+        }
+        // The edit still replaces the predecessor in memory. Keep that state and the payload:
+        // a later successful claim writes the whole preferences file, including all retirements,
+        // before returning the replacement. Rolling back here would lose a valid incoming launch.
+        // If the process dies before any write succeeds, only the earlier durable state survives.
+        Logger.w(TAG, "Failed to persist full-screen launch replacement");
+        return true;
+      } catch (Exception e) {
+        Logger.e(TAG, "Failed to record full-screen launch", e);
+        return false;
+      }
+    }
+  }
+
+  /** Claims a full-screen launch, if its id was issued and not returned yet. */
+  static boolean claimFullScreenLaunch(String pendingIntentId) {
+    synchronized (lock) {
+      try {
+        SharedPreferences preferences = getPreferences();
+        Set<String> unclaimed =
+            preferences.getStringSet(UNCLAIMED_FULL_SCREEN_IDS_KEY, Collections.emptySet());
+        if (!unclaimed.contains(pendingIntentId)) {
+          return false;
+        }
+
+        Set<String> remaining = new HashSet<>(unclaimed);
+        remaining.remove(pendingIntentId);
+        if (preferences.edit().putStringSet(UNCLAIMED_FULL_SCREEN_IDS_KEY, remaining).commit()) {
+          return true;
+        }
+        // A claim missing from disk could be returned again by a later process. The failed edit
+        // still removed the id in memory: put it back so that a later call can claim it.
+        preferences
+            .edit()
+            .putStringSet(UNCLAIMED_FULL_SCREEN_IDS_KEY, new HashSet<>(unclaimed))
+            .apply();
+        Logger.w(TAG, "Failed to persist full-screen launch claim");
+        return false;
+      } catch (Exception e) {
+        Logger.e(TAG, "Failed to claim full-screen launch", e);
+        return false;
+      }
+    }
+  }
+
+  @VisibleForTesting
+  static int unclaimedFullScreenLaunchCountForTesting() {
+    synchronized (lock) {
+      return getPreferences()
+          .getStringSet(UNCLAIMED_FULL_SCREEN_IDS_KEY, Collections.emptySet())
+          .size();
+    }
+  }
+
+  @VisibleForTesting
+  static void clearForTesting() {
+    synchronized (lock) {
+      commit(getPreferences().edit().clear());
+    }
+  }
+
+  private static void commit(SharedPreferences.Editor editor) {
+    // The claim already holds in memory; only a later process could return it again.
+    if (!editor.commit()) {
+      Logger.w(TAG, "Failed to persist initial notification claim");
+    }
+  }
+
+  private static SharedPreferences getPreferences() {
+    return ContextHolder.getApplicationContext()
+        .getSharedPreferences(PREFERENCES_FILE, Context.MODE_PRIVATE);
+  }
+}

package/android/src/main/java/app/notifee/core/Notifee.java

@@ -27,6 +27,7 @@ import android.os.Bundle;
 import android.provider.Settings;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
+import androidx.annotation.VisibleForTesting;
 import androidx.core.app.NotificationManagerCompat;
 import app.notifee.core.event.InitialNotificationEvent;
 import app.notifee.core.event.MainComponentEvent;
@@ -43,7 +44,10 @@ import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListeningExecutorService;
 import com.google.common.util.concurrent.MoreExecutors;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
+import java.util.Set;
+import java.util.WeakHashMap;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 
@@ -57,6 +61,14 @@ public class Notifee {
   private static final ListeningExecutorService lExecutorService =
       MoreExecutors.listeningDecorator(executorService);
 
+  private static final Object initialNotificationLock = new Object();
+  // Activity Intents without an interaction id already returned by getInitialNotification().
+  // Intent has identity equality; weak keys let entries go with their Activity.
+  private static final Set<Intent> consumedInitialNotificationIntents =
+      Collections.newSetFromMap(new WeakHashMap<>());
+  // Latest full-screen launch recorded by NotificationReceiverActivity, not returned yet.
+  @Nullable private static Intent recordedFullScreenLaunchIntent;
+
   @KeepForSdk public static final int REQUEST_CODE_NOTIFICATION_PERMISSION = 11111;
 
   @KeepForSdk
@@ -432,31 +444,141 @@ public class Notifee {
 
   @KeepForSdk
   public void getInitialNotification(Activity activity, MethodCallResult<Bundle> result) {
-    InitialNotificationEvent event = EventBus.removeStickEvent(InitialNotificationEvent.class);
-    Bundle initialNotificationBundle = new Bundle();
+    Bundle initialNotificationBundle;
+    synchronized (initialNotificationLock) {
+      initialNotificationBundle = consumeInitialNotification(activity);
+    }
+    result.onComplete(null, initialNotificationBundle);
+  }
+
+  /** Checks payload shape before any capture or durable retirement. */
+  static boolean isValidFullScreenLaunch(@Nullable Intent intent) {
+    try {
+      if (intent == null
+          || intent.hasExtra(NotificationPendingIntent.EVENT_TYPE_INTENT_KEY)
+          || intent.getBundleExtra("notification") == null) return false;
+      Object notificationId = intent.getBundleExtra("notification").get("id");
+      return notificationId instanceof String
+          && !((String) notificationId).isEmpty()
+          && intent.getStringExtra(NotificationPendingIntent.PENDING_INTENT_ID_INTENT_KEY) != null;
+    } catch (Exception e) {
+      return false;
+    }
+  }
 
-    if (event != null) {
-      initialNotificationBundle.putAll(event.getExtras());
-      initialNotificationBundle.putBundle("notification", event.getNotificationModel().toBundle());
-      result.onComplete(null, initialNotificationBundle);
-      return;
-    } else if (activity != null) {
-      try {
-        // get intent from current activity
-        Intent intent = activity.getIntent();
-        if (intent != null && intent.getExtras() != null && intent.hasExtra("notification")) {
-          initialNotificationBundle.putBundle(
-              "notification", intent.getBundleExtra("notification"));
-          result.onComplete(null, initialNotificationBundle);
-          return;
+  /**
+   * Records the launch of a full-screen Intent, from {@link FullScreenNotificationActivity} started
+   * before its consumer, independently of React Native. An existing launch Activity gets the launch
+   * through onNewIntent(), which React Native drops while its instance starts, and its getIntent()
+   * keeps returning the Intent that created it. A launch is recorded only if it was issued and not
+   * returned yet, in place of an earlier one, as the sticky event keeps the latest tap.
+   */
+  static void recordFullScreenLaunch(@Nullable Intent intent) {
+    try {
+      if (!isValidFullScreenLaunch(intent)) return;
+      String pendingIntentId =
+          intent.getStringExtra(NotificationPendingIntent.PENDING_INTENT_ID_INTENT_KEY);
+
+      synchronized (initialNotificationLock) {
+        if (InitialNotificationLedger.recordFullScreenLaunch(pendingIntentId)) {
+          recordedFullScreenLaunchIntent = new Intent(intent);
+          String mainComponent = intent.getStringExtra("mainComponent");
+          if (mainComponent != null) {
+            // A cold process lost the event posted when the notification was displayed. Restore
+            // it before the consumer asks for its React component during Activity creation.
+            EventBus.postSticky(new MainComponentEvent(mainComponent));
+          }
         }
-      } catch (Exception e) {
-        Logger.e(TAG, "getInitialNotification", e);
       }
+    } catch (Exception e) {
+      Logger.e(TAG, "recordFullScreenLaunch", e);
+    }
+  }
+
+  private static @Nullable Bundle consumeInitialNotification(@Nullable Activity activity) {
+    InitialNotificationEvent event = EventBus.getStickyEvent(InitialNotificationEvent.class);
+
+    if (event != null) {
+      InitialNotificationLedger.TapClaim claim =
+          InitialNotificationLedger.claimTap(event.getTapSequence());
+      if (claim == InitialNotificationLedger.TapClaim.RETRY) {
+        // Keep the sticky payload, including ACTION_PRESS input, for a later durable claim.
+        return null;
+      }
+      // Remove only this event: a concurrent new tap must not be discarded with it.
+      EventBus.removeStickyEvent(event);
+      if (claim == InitialNotificationLedger.TapClaim.CLAIMED) {
+        Bundle initialNotificationBundle = new Bundle();
+        initialNotificationBundle.putAll(event.getExtras());
+        initialNotificationBundle.putBundle(
+            "notification", event.getNotificationModel().toBundle());
+        return initialNotificationBundle;
+      }
+      // Otherwise this tap was already returned through its launch Intent.
     }
 
-    // If no initial notification, return
-    result.onComplete(null, null);
+    Bundle recordedLaunchBundle = consumeActivityIntent(recordedFullScreenLaunchIntent);
+    if (recordedLaunchBundle != null) {
+      recordedFullScreenLaunchIntent = null;
+      return recordedLaunchBundle;
+    }
+
+    if (activity == null) {
+      return null;
+    }
+
+    // get intent from current activity
+    return consumeActivityIntent(activity.getIntent());
+  }
+
+  private static @Nullable Bundle consumeActivityIntent(@Nullable Intent intent) {
+    if (intent == null) {
+      return null;
+    }
+
+    try {
+      Bundle notification = intent.getBundleExtra("notification");
+      if (notification == null || !claimActivityIntent(intent)) {
+        return null;
+      }
+
+      Bundle initialNotificationBundle = new Bundle();
+      initialNotificationBundle.putBundle("notification", notification);
+      return initialNotificationBundle;
+    } catch (Exception e) {
+      Logger.e(TAG, "getInitialNotification", e);
+    }
+
+    return null;
+  }
+
+  /** Claims the interaction an Activity Intent carries, if it was not returned yet. */
+  private static boolean claimActivityIntent(Intent intent) {
+    String pendingIntentId =
+        intent.getStringExtra(NotificationPendingIntent.PENDING_INTENT_ID_INTENT_KEY);
+
+    if (intent.hasExtra(NotificationPendingIntent.EVENT_TYPE_INTENT_KEY)) {
+      // Launch Intent of a NotificationPendingIntent tap. The tap's sticky event returns it; the
+      // Intent stands in only for a recorded tap whose event was lost with its process.
+      return pendingIntentId != null && InitialNotificationLedger.claimLatestTap(pendingIntentId);
+    }
+
+    if (pendingIntentId != null) {
+      return InitialNotificationLedger.claimFullScreenLaunch(pendingIntentId);
+    }
+
+    // No id (foreign Intent, or full-screen Intent of an earlier version): consumption follows the
+    // Intent object.
+    return consumedInitialNotificationIntents.add(intent);
+  }
+
+  /** Drops in-memory state, as a new process would. */
+  @VisibleForTesting
+  static void resetInitialNotificationStateForTesting() {
+    synchronized (initialNotificationLock) {
+      consumedInitialNotificationIntents.clear();
+      recordedFullScreenLaunchIntent = null;
+    }
   }
 
   @KeepForSdk

package/android/src/main/java/app/notifee/core/NotificationManager.java

@@ -415,16 +415,54 @@ class NotificationManager {
                           launchIntent.putExtra(
                               "mainComponent", fullScreenActionBundle.getMainComponent());
                           launchIntent.putExtra("notification", notificationModel.toBundle());
+                          launchIntent.putExtra(
+                              NotificationPendingIntent.PENDING_INTENT_ID_INTENT_KEY,
+                              InitialNotificationLedger.issueFullScreenLaunchId());
                           EventBus.postSticky(
                               new MainComponentEvent(fullScreenActionBundle.getMainComponent()));
                         }
 
-                        PendingIntent fullScreenPendingIntent =
-                            PendingIntent.getActivity(
-                                getApplicationContext(),
-                                notificationModel.getHashCode(),
-                                launchIntent,
-                                PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_MUTABLE);
+                        PendingIntent fullScreenPendingIntent;
+                        if (launchIntent.hasExtra(
+                            NotificationPendingIntent.PENDING_INTENT_ID_INTENT_KEY)) {
+                          // A sole Activity target must run before the consumer is started. In a
+                          // getActivities array, an intermediate, hidden Activity can stay
+                          // uncreated.
+                          Intent receiverIntent =
+                              new Intent(
+                                  getApplicationContext(), FullScreenNotificationActivity.class);
+                          receiverIntent.setAction(FullScreenNotificationActivity.ACTION);
+                          // Preserve the component partition of the original consumer
+                          // PendingIntent.
+                          // Payload, flags and mainComponent remain updateable extras of that
+                          // identity.
+                          receiverIntent.setData(
+                              android.net.Uri.fromParts(
+                                  "notifee-full-screen", launchActivityClass.getName(), null));
+                          receiverIntent.putExtras(launchIntent);
+                          // An unfinished NoDisplay root can lose a queued new Intent when it
+                          // finishes in onCreate. Give each capture its own short-lived task.
+                          receiverIntent.setFlags(
+                              Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_MULTIPLE_TASK);
+                          // Match the effective NEW_TASK flag of the original getActivity flow.
+                          launchIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+                          receiverIntent.putExtra(
+                              FullScreenNotificationActivity.LAUNCH_INTENT,
+                              new Intent(launchIntent).replaceExtras((Bundle) null));
+                          fullScreenPendingIntent =
+                              PendingIntent.getActivity(
+                                  getApplicationContext(),
+                                  notificationModel.getHashCode(),
+                                  receiverIntent,
+                                  PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_MUTABLE);
+                        } else {
+                          fullScreenPendingIntent =
+                              PendingIntent.getActivity(
+                                  getApplicationContext(),
+                                  notificationModel.getHashCode(),
+                                  launchIntent,
+                                  PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_MUTABLE);
+                        }
                         builder.setFullScreenIntent(fullScreenPendingIntent, true);
                       }
 

package/android/src/main/java/app/notifee/core/NotificationPendingIntent.java

@@ -29,6 +29,14 @@ import java.util.UUID;
 public class NotificationPendingIntent {
   public static final String EVENT_TYPE_INTENT_KEY = "notifee_event_type";
   public static final String NOTIFICATION_ID_INTENT_KEY = "notification_id";
+
+  /**
+   * Random id shared by the Intents of one PendingIntent, or issued for a full-screen Intent, so a
+   * launch Intent can be matched with the interactions recorded by {@link
+   * InitialNotificationLedger}.
+   */
+  static final String PENDING_INTENT_ID_INTENT_KEY = "notifee_pending_intent_id";
+
   private static final String TAG = "NotificationPendingIntent";
 
   /**
@@ -74,6 +82,12 @@ public class NotificationPendingIntent {
     setIntentExtras(launchActivityIntent, eventType, notificationId, extraKeys, extraBundles);
     setIntentExtras(receiverIntent, eventType, notificationId, extraKeys, extraBundles);
 
+    String pendingIntentId = UUID.randomUUID().toString();
+    if (launchActivityIntent != null) {
+      launchActivityIntent.putExtra(PENDING_INTENT_ID_INTENT_KEY, pendingIntentId);
+    }
+    receiverIntent.putExtra(PENDING_INTENT_ID_INTENT_KEY, pendingIntentId);
+
     // Create pending intent with activities
     int uniqueInt = UUID.randomUUID().hashCode();
     Intent[] intents;