react-native-notify-kit 10.8.1 → 10.9.1

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);
                       }
 
@@ -662,6 +700,12 @@ class NotificationManager {
 
   static ListenableFuture<Void> displayNotification(
       NotificationModel notificationModel, Bundle triggerBundle) {
+    // Reject invalid native/bridge opt-in before dispatching any START or posting a notification.
+    try {
+      notificationModel.getAndroid().getForegroundServiceBestEffortStopAfterMs();
+    } catch (RuntimeException invalidOption) {
+      return Futures.immediateFailedFuture(invalidOption);
+    }
     return new ExtendedListenableFuture<>(notificationBundleToBuilder(notificationModel))
         .continueWith(
             (taskResult) -> {

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;

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

@@ -19,6 +19,7 @@ package app.notifee.core;
 
 import static app.notifee.core.NotificationPendingIntent.EVENT_TYPE_INTENT_KEY;
 import static app.notifee.core.NotificationPendingIntent.NOTIFICATION_ID_INTENT_KEY;
+import static app.notifee.core.NotificationPendingIntent.PENDING_INTENT_ID_INTENT_KEY;
 import static app.notifee.core.event.NotificationEvent.TYPE_ACTION_PRESS;
 import static app.notifee.core.event.NotificationEvent.TYPE_PRESS;
 
@@ -98,7 +99,11 @@ public class NotificationReceiverHandler {
     }
 
     InitialNotificationEvent initialNotificationEvent =
-        new InitialNotificationEvent(notificationModel, extras);
+        new InitialNotificationEvent(
+            notificationModel,
+            extras,
+            InitialNotificationLedger.recordTap(
+                intent.getStringExtra(PENDING_INTENT_ID_INTENT_KEY)));
     EventBus.postSticky(initialNotificationEvent);
 
     // Send event
@@ -127,7 +132,11 @@ public class NotificationReceiverHandler {
     EventBus.post(new NotificationEvent(TYPE_PRESS, notificationModel, extras));
 
     InitialNotificationEvent initialNotificationEvent =
-        new InitialNotificationEvent(notificationModel, extras);
+        new InitialNotificationEvent(
+            notificationModel,
+            extras,
+            InitialNotificationLedger.recordTap(
+                intent.getStringExtra(PENDING_INTENT_ID_INTENT_KEY)));
     EventBus.postSticky(initialNotificationEvent);
 
     if (pressActionBundle == null) {

package/android/src/main/java/app/notifee/core/event/InitialNotificationEvent.java

@@ -26,10 +26,21 @@ public class InitialNotificationEvent {
 
   private NotificationModel notificationModel;
   private Bundle extras;
+  private long tapSequence;
 
   public InitialNotificationEvent(NotificationModel notificationModel, Bundle extras) {
+    this(notificationModel, extras, 0);
+  }
+
+  /**
+   * @param tapSequence sequence number recorded for the tap that produced this event, or 0 when the
+   *     tap is not tracked.
+   */
+  public InitialNotificationEvent(
+      NotificationModel notificationModel, Bundle extras, long tapSequence) {
     this.notificationModel = notificationModel;
     this.extras = extras;
+    this.tapSequence = tapSequence;
   }
 
   public NotificationModel getNotificationModel() {
@@ -40,6 +51,10 @@ public class InitialNotificationEvent {
     return extras;
   }
 
+  public long getTapSequence() {
+    return tapSequence;
+  }
+
   public Map<String, Object> toMap() {
     Map<String, Object> initialNotificationEventMap = new HashMap<>();
     initialNotificationEventMap.put("notificationModel", notificationModel.toBundle());

package/android/src/main/java/app/notifee/core/event/NotificationEvent.java

@@ -41,6 +41,8 @@ public class NotificationEvent {
 
   @KeepForSdk public static final int TYPE_FG_TIMEOUT = 9;
 
+  @KeepForSdk public static final int TYPE_FG_RUN_LIMIT_REACHED = 10;
+
   private final int type;
   private final Bundle extras;
   private final NotificationModel notification;
@@ -85,6 +87,10 @@ public class NotificationEvent {
         eventDetailMap.put("input", input);
       }
 
+      Bundle runLimit = extras.getBundle("foregroundServiceRunLimit");
+      if (runLimit != null)
+        eventDetailMap.put("foregroundServiceRunLimit", ObjectUtils.bundleToMap(runLimit));
+
       if (extras.containsKey("startId")) {
         eventDetailMap.put("startId", extras.getInt("startId"));
       }