react-native-notify-kit 9.4.0 → 9.5.0

package/android/src/androidTest/java/app/notifee/core/database/WorkDataRepositoryRaceTest.java

@@ -0,0 +1,221 @@
+package app.notifee.core.database;
+
+/*
+ * 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
+ *
+ * ---
+ *
+ * NOT RUN IN CI.
+ *
+ * This test hits a real Room in-memory database and must be executed on a connected device or
+ * emulator via:
+ *
+ *     cd apps/smoke/android
+ *     ./gradlew :react-native-notify-kit:connectedDebugAndroidTest
+ *
+ * before merging any change that touches the WorkDataRepository layer or the Room schema. A
+ * follow-up task tracks wiring this into CI with reactivecircus/android-emulator-runner — see the
+ * "Wire androidTest into CI" issue linked from the #549 fix PR description.
+ *
+ * The scenarios below are the instrumented analogues of the repro-549-findings.md harness:
+ * post-cancel consistency (Scenario B), post-create persistence (Scenario C), and concurrent
+ * stress (Scenario D). They run 100 iterations each and must observe zero inconsistencies after
+ * the #549 fix; any non-zero count is a regression.
+ */
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import androidx.room.Room;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.platform.app.InstrumentationRegistry;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+@RunWith(AndroidJUnit4.class)
+public class WorkDataRepositoryRaceTest {
+
+  private NotifeeCoreDatabase db;
+  private WorkDataRepository repo;
+  private ListeningExecutorService executor;
+
+  @Before
+  public void setUp() {
+    db =
+        Room.inMemoryDatabaseBuilder(
+                InstrumentationRegistry.getInstrumentation().getTargetContext(),
+                NotifeeCoreDatabase.class)
+            .allowMainThreadQueries()
+            .build();
+    // Shared cached thread pool matches the production executor's concurrency profile.
+    executor = MoreExecutors.listeningDecorator(Executors.newCachedThreadPool());
+    repo = new WorkDataRepository(db.workDao(), executor);
+  }
+
+  @After
+  public void tearDown() {
+    db.close();
+    executor.shutdownNow();
+  }
+
+  // ------- Scenario B analogue: post-cancel consistency -------
+
+  @Test
+  public void deleteAll_thenGetAll_isEmpty_100iterations()
+      throws ExecutionException, InterruptedException, java.util.concurrent.TimeoutException {
+    for (int i = 0; i < 100; i++) {
+      // Seed 20 rows
+      List<ListenableFuture<Void>> seedFutures = new ArrayList<>(20);
+      for (int j = 0; j < 20; j++) {
+        seedFutures.add(repo.insert(entity("b-" + i + "-" + j)));
+      }
+      for (ListenableFuture<Void> f : seedFutures) {
+        f.get(2, TimeUnit.SECONDS);
+      }
+
+      // Assert seeded
+      assertEquals(20, repo.getAll().get(2, TimeUnit.SECONDS).size());
+
+      // Cancel all, then immediately read — must be empty.
+      repo.deleteAll().get(2, TimeUnit.SECONDS);
+      int immediateCount = repo.getAll().get(2, TimeUnit.SECONDS).size();
+      assertEquals(
+          "iteration " + i + ": deleteAll must complete before its future resolves",
+          0,
+          immediateCount);
+    }
+  }
+
+  // ------- Scenario C analogue: post-create persistence -------
+
+  @Test
+  public void insert_thenGet_isVisible_100iterations()
+      throws ExecutionException, InterruptedException, java.util.concurrent.TimeoutException {
+    for (int i = 0; i < 100; i++) {
+      repo.deleteAll().get(2, TimeUnit.SECONDS);
+      String id = "c-" + i;
+      repo.insert(entity(id)).get(2, TimeUnit.SECONDS);
+
+      WorkDataEntity row = repo.getWorkDataById(id).get(2, TimeUnit.SECONDS);
+      assertTrue(
+          "iteration " + i + ": insert future resolved but row is not in Room yet", row != null);
+      assertEquals(id, row.getId());
+    }
+  }
+
+  // ------- Delete-by-id consistency -------
+
+  @Test
+  public void deleteById_thenGet_isNull_100iterations()
+      throws ExecutionException, InterruptedException, java.util.concurrent.TimeoutException {
+    for (int i = 0; i < 100; i++) {
+      String id = "d-" + i;
+      repo.insert(entity(id)).get(2, TimeUnit.SECONDS);
+      repo.deleteById(id).get(2, TimeUnit.SECONDS);
+      WorkDataEntity row = repo.getWorkDataById(id).get(2, TimeUnit.SECONDS);
+      assertTrue("iteration " + i + ": deleteById resolved but row still present", row == null);
+    }
+  }
+
+  // ------- Update visibility -------
+
+  @Test
+  public void update_thenGet_reflectsNewTrigger_100iterations()
+      throws ExecutionException, InterruptedException, java.util.concurrent.TimeoutException {
+    for (int i = 0; i < 100; i++) {
+      String id = "u-" + i;
+      byte[] notification = new byte[] {1, 2, 3};
+      byte[] initialTrigger = new byte[] {(byte) i};
+      repo.insert(new WorkDataEntity(id, notification, initialTrigger, false))
+          .get(2, TimeUnit.SECONDS);
+
+      byte[] updatedTrigger = new byte[] {(byte) (i + 100)};
+      repo.update(new WorkDataEntity(id, notification, updatedTrigger, true))
+          .get(2, TimeUnit.SECONDS);
+
+      WorkDataEntity row = repo.getWorkDataById(id).get(2, TimeUnit.SECONDS);
+      assertTrue(row != null);
+      assertEquals(
+          "iteration " + i + ": updated trigger byte must be visible immediately",
+          (byte) (i + 100),
+          row.getTrigger()[0]);
+      assertTrue(row.getWithAlarmManager());
+    }
+  }
+
+  // ------- Scenario D analogue: concurrent stress -------
+
+  /**
+   * Fire 20 concurrent insert and 20 concurrent deleteAll operations across a fixed thread pool and
+   * verify the system reaches a deterministic final state after all futures complete. This does NOT
+   * assert a specific final count — ordering between concurrent creates and cancels is
+   * implementation-defined — but it does assert that every future completes successfully and the DB
+   * is readable at the end.
+   */
+  @Test
+  public void concurrentInsertAndDelete_allFuturesComplete()
+      throws ExecutionException, InterruptedException, java.util.concurrent.TimeoutException {
+    ExecutorService testPool = Executors.newFixedThreadPool(8);
+    try {
+      List<ListenableFuture<Void>> futures = new ArrayList<>();
+      for (int i = 0; i < 20; i++) {
+        futures.add(repo.insert(entity("s-" + i)));
+        if (i % 3 == 0) {
+          futures.add(repo.deleteAll());
+        }
+      }
+      for (ListenableFuture<Void> f : futures) {
+        f.get(5, TimeUnit.SECONDS);
+      }
+      // Final read must succeed — we only assert the DB is readable, not the count.
+      int finalCount = repo.getAll().get(2, TimeUnit.SECONDS).size();
+      assertTrue("final count must be non-negative: " + finalCount, finalCount >= 0);
+    } finally {
+      testPool.shutdownNow();
+    }
+  }
+
+  // ------- DAO exceptions surface via ExecutionException -------
+
+  @Test
+  public void insertDuplicatePrimaryKey_failsFutureWithExecutionException()
+      throws ExecutionException, InterruptedException, java.util.concurrent.TimeoutException {
+    repo.insert(entity("dup")).get(2, TimeUnit.SECONDS);
+    try {
+      // Room throws SQLiteConstraintException on duplicate primary key when using OnConflict.ABORT
+      // (the default). If the DAO uses REPLACE this test will pass trivially; adjust when the
+      // DAO's @Insert strategy changes.
+      repo.insert(entity("dup")).get(2, TimeUnit.SECONDS);
+      // If we reach here the DAO uses REPLACE or similar — mark the test as passing but log.
+    } catch (ExecutionException e) {
+      assertFalse("ExecutionException must wrap a real cause, not null", e.getCause() == null);
+    } catch (Throwable unexpected) {
+      fail("Expected ExecutionException or success, got: " + unexpected);
+    }
+  }
+
+  // ------- helpers -------
+
+  private static WorkDataEntity entity(String id) {
+    return new WorkDataEntity(id, new byte[] {0}, new byte[] {0}, false);
+  }
+}

package/android/src/androidTest/res/drawable/test_icon.xml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  Tiny transparent vector drawable used as a smallIcon placeholder in
+  DoScheduledWorkOrderingTest so NotificationManagerCompat.notify() does not
+  reject the test notification for missing icon. Only referenced by the
+  androidTest APK — never shipped to consumers.
+-->
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+  <path android:fillColor="#00000000" android:pathData="M0,0h24v24H0z" />
+</vector>

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

@@ -26,6 +26,7 @@ import android.content.Context;
 import android.content.Intent;
 import android.os.Build;
 import android.os.Bundle;
+import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.core.app.AlarmManagerCompat;
 import app.notifee.core.database.WorkDataEntity;
@@ -40,10 +41,14 @@ import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.ListeningExecutorService;
 import com.google.common.util.concurrent.MoreExecutors;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
 
 class NotifeeAlarmManager {
   private static final String TAG = "NotifeeAlarmManager";
@@ -52,6 +57,59 @@ class NotifeeAlarmManager {
   private static final ListeningExecutorService alarmManagerListeningExecutor =
       MoreExecutors.listeningDecorator(alarmManagerExecutor);
 
+  // Scheduler used only as the timeout clock for Futures.withTimeout on Room
+  // writes happening inside BroadcastReceiver.goAsync() scopes. Broadcasts have
+  // ~10s before Android kills the process, so we cap the Room wait at 8s and
+  // call pendingResult.finish() anyway on timeout to avoid ANRs.
+  private static final ScheduledExecutorService TIMEOUT_SCHEDULER =
+      Executors.newSingleThreadScheduledExecutor();
+  private static final long RECEIVER_WRITE_TIMEOUT_SECONDS = 8;
+
+  /**
+   * Wraps {@code future} in a {@link Futures#withTimeout} safety net and arranges for {@code
+   * pendingResult.finish()} to be called exactly once — on success, on failure, or on timeout. Use
+   * from a {@link BroadcastReceiver#goAsync} scope where the receiver must tell Android "I'm done"
+   * within ~10s or the process is killed. Timeouts are logged at {@code WARN} with the supplied
+   * {@code logContext}; real failures at {@code ERROR}.
+   */
+  private static void finishReceiverWhenDone(
+      @NonNull ListenableFuture<?> future,
+      @Nullable BroadcastReceiver.PendingResult pendingResult,
+      @NonNull String logContext) {
+    ListenableFuture<?> bounded =
+        Futures.withTimeout(
+            future, RECEIVER_WRITE_TIMEOUT_SECONDS, TimeUnit.SECONDS, TIMEOUT_SCHEDULER);
+    Futures.addCallback(
+        bounded,
+        new FutureCallback<Object>() {
+          @Override
+          public void onSuccess(Object result) {
+            if (pendingResult != null) {
+              pendingResult.finish();
+            }
+          }
+
+          @Override
+          public void onFailure(@NonNull Throwable t) {
+            if (t instanceof TimeoutException) {
+              Logger.w(
+                  TAG,
+                  "Room write for "
+                      + logContext
+                      + " did not complete within "
+                      + RECEIVER_WRITE_TIMEOUT_SECONDS
+                      + "s; finishing BroadcastReceiver anyway to avoid ANR");
+            } else {
+              Logger.e(TAG, "Failure in " + logContext, new Exception(t));
+            }
+            if (pendingResult != null) {
+              pendingResult.finish();
+            }
+          }
+        },
+        alarmManagerListeningExecutor);
+  }
+
   static void displayScheduledNotification(
       Bundle alarmManagerNotification, @Nullable BroadcastReceiver.PendingResult pendingResult) {
     if (alarmManagerNotification == null) {
@@ -71,72 +129,60 @@ class NotifeeAlarmManager {
 
     WorkDataRepository workDataRepository = new WorkDataRepository(getApplicationContext());
 
-    ListenableFuture<?> displayFuture =
-        new ExtendedListenableFuture<>(workDataRepository.getWorkDataById(id))
-            .continueWith(
-                workDataEntity -> {
-                  Bundle notificationBundle;
-
-                  Bundle triggerBundle;
-
-                  if (workDataEntity == null
-                      || workDataEntity.getNotification() == null
-                      || workDataEntity.getTrigger() == null) {
-                    // check if notification bundle is stored with Work Manager
-                    Logger.w(
-                        TAG,
-                        "Attempted to handle doScheduledWork but no notification data was found.");
-                    return Futures.immediateFuture(null);
-                  } else {
-                    triggerBundle = ObjectUtils.bytesToBundle(workDataEntity.getTrigger());
-                    notificationBundle =
-                        ObjectUtils.bytesToBundle(workDataEntity.getNotification());
-                  }
-
-                  NotificationModel notificationModel =
-                      NotificationModel.fromBundle(notificationBundle);
-
-                  return new ExtendedListenableFuture<>(
-                          NotificationManager.displayNotification(notificationModel, triggerBundle))
-                      .continueWith(
-                          voidDisplayedNotification -> {
-                            if (triggerBundle.containsKey("repeatFrequency")
-                                && ObjectUtils.getInt(triggerBundle.get("repeatFrequency")) != -1) {
-                              TimestampTriggerModel trigger =
-                                  TimestampTriggerModel.fromBundle(triggerBundle);
-                              // scheduleTimestampTriggerNotification() calls setNextTimestamp()
-                              // internally, so we must NOT call it here to avoid double-advancing
-                              scheduleTimestampTriggerNotification(notificationModel, trigger);
-                              WorkDataRepository.getInstance(getApplicationContext())
-                                  .update(
-                                      new WorkDataEntity(
-                                          id,
-                                          workDataEntity.getNotification(),
-                                          ObjectUtils.bundleToBytes(trigger.toBundle()),
-                                          true));
-                            } else {
-                              // not repeating, delete database entry if work is a one-time request
-                              WorkDataRepository.getInstance(getApplicationContext())
-                                  .deleteById(id);
-                            }
-                            return Futures.immediateFuture(null);
-                          },
-                          alarmManagerExecutor);
-                },
-                alarmManagerExecutor)
-            .addOnCompleteListener(
-                (e, result) -> {
-                  try {
-                    if (e != null) {
-                      Logger.e(TAG, "Failed to display notification", e);
-                    }
-                  } finally {
-                    if (pendingResult != null) {
-                      pendingResult.finish();
+    // Chain: read → display → persist (update for repeat / delete for one-shot).
+    // The final Room write is awaited before pendingResult.finish() so the
+    // BroadcastReceiver only tells Android "I'm done" once the next-fire anchor
+    // (or the deletion) has actually landed in Room. Without this, process death
+    // between finish() and the enqueued write could lose the updated timestamp
+    // and cause the same alarm to fire again on the next reboot. See #549 audit
+    // callers #6 and #7.
+    ListenableFuture<Void> displayAndPersistFuture =
+        Futures.transformAsync(
+            workDataRepository.getWorkDataById(id),
+            workDataEntity -> {
+              if (workDataEntity == null
+                  || workDataEntity.getNotification() == null
+                  || workDataEntity.getTrigger() == null) {
+                Logger.w(
+                    TAG, "Attempted to handle doScheduledWork but no notification data was found.");
+                return Futures.immediateFuture(null);
+              }
+
+              Bundle triggerBundle = ObjectUtils.bytesToBundle(workDataEntity.getTrigger());
+              Bundle notificationBundle =
+                  ObjectUtils.bytesToBundle(workDataEntity.getNotification());
+              NotificationModel notificationModel =
+                  NotificationModel.fromBundle(notificationBundle);
+
+              return Futures.transformAsync(
+                  NotificationManager.displayNotification(notificationModel, triggerBundle),
+                  voidDisplayedNotification -> {
+                    if (triggerBundle.containsKey("repeatFrequency")
+                        && ObjectUtils.getInt(triggerBundle.get("repeatFrequency")) != -1) {
+                      TimestampTriggerModel trigger =
+                          TimestampTriggerModel.fromBundle(triggerBundle);
+                      // scheduleTimestampTriggerNotification() calls setNextTimestamp()
+                      // internally, so we must NOT call it here to avoid double-advancing
+                      scheduleTimestampTriggerNotification(notificationModel, trigger);
+                      return WorkDataRepository.getInstance(getApplicationContext())
+                          .update(
+                              new WorkDataEntity(
+                                  id,
+                                  workDataEntity.getNotification(),
+                                  ObjectUtils.bundleToBytes(trigger.toBundle()),
+                                  true));
                     }
-                  }
-                },
-                alarmManagerExecutor);
+                    // not repeating, delete database entry if work is a one-time request
+                    return WorkDataRepository.getInstance(getApplicationContext()).deleteById(id);
+                  },
+                  alarmManagerExecutor);
+            },
+            alarmManagerExecutor);
+
+    // Awaits the Room write before pendingResult.finish(), bounded by the 8s
+    // ANR safety timeout. Handles success, failure, and timeout uniformly.
+    finishReceiverWhenDone(
+        displayAndPersistFuture, pendingResult, "displayScheduledNotification[" + id + "]");
   }
 
   public static PendingIntent getAlarmManagerIntentForNotification(String notificationId) {
@@ -283,10 +329,18 @@ class NotifeeAlarmManager {
             alarmManagerListeningExecutor);
   }
 
-  /* On reboot, reschedule trigger notifications created via alarm manager  */
-  void rescheduleNotification(WorkDataEntity workDataEntity) {
+  /**
+   * On reboot, reschedule one trigger notification created via alarm manager.
+   *
+   * <p>Returns a future that completes when Room has persisted the updated next-fire anchor. The
+   * caller MUST await this future before calling {@code pendingResult.finish()} — otherwise Android
+   * may kill the boot receiver's process before Room has drained, and the next reboot will
+   * reschedule from the stale anchor. This bug is NOT in upstream invertase/notifee#549 and was
+   * surfaced only by the pre-fix-549-audit.md read-only caller audit (Caller #8).
+   */
+  ListenableFuture<Void> rescheduleNotification(WorkDataEntity workDataEntity) {
     if (workDataEntity.getNotification() == null || workDataEntity.getTrigger() == null) {
-      return;
+      return Futures.immediateFuture(null);
     }
 
     byte[] notificationBytes = workDataEntity.getNotification();
@@ -302,22 +356,23 @@ class NotifeeAlarmManager {
       case 0:
         TimestampTriggerModel trigger = TimestampTriggerModel.fromBundle(triggerBundle);
         if (!trigger.getWithAlarmManager()) {
-          return;
+          return Futures.immediateFuture(null);
         }
 
         scheduleTimestampTriggerNotification(notificationModel, trigger);
-        // Persist updated timestamp so next reboot starts from the correct anchor
-        WorkDataRepository.getInstance(getApplicationContext())
+        // Persist updated timestamp so next reboot starts from the correct anchor.
+        return WorkDataRepository.getInstance(getApplicationContext())
             .update(
                 new WorkDataEntity(
                     workDataEntity.getId(),
                     workDataEntity.getNotification(),
                     ObjectUtils.bundleToBytes(trigger.toBundle()),
                     workDataEntity.getWithAlarmManager()));
-        break;
       case 1:
         // TODO: support interval triggers with alarm manager
-        break;
+        return Futures.immediateFuture(null);
+      default:
+        return Futures.immediateFuture(null);
     }
   }
 
@@ -328,19 +383,45 @@ class NotifeeAlarmManager {
         new FutureCallback<List<WorkDataEntity>>() {
           @Override
           public void onSuccess(List<WorkDataEntity> workDataEntities) {
-            try {
-              for (WorkDataEntity workDataEntity : workDataEntities) {
-                rescheduleNotification(workDataEntity);
-              }
-            } finally {
+            Logger.d(
+                TAG,
+                "Reschedule starting for "
+                    + (workDataEntities != null ? workDataEntities.size() : 0)
+                    + " recurring alarms");
+
+            if (workDataEntities == null || workDataEntities.isEmpty()) {
               if (pendingResult != null) {
                 pendingResult.finish();
               }
+              return;
             }
+
+            List<ListenableFuture<Void>> updateFutures = new ArrayList<>(workDataEntities.size());
+            for (WorkDataEntity workDataEntity : workDataEntities) {
+              try {
+                updateFutures.add(rescheduleNotification(workDataEntity));
+              } catch (Throwable t) {
+                // A single bad entity must not prevent the rest of the batch
+                // from being rescheduled — log and continue.
+                Logger.w(
+                    TAG,
+                    "Failed to reschedule entity "
+                        + workDataEntity.getId()
+                        + ": "
+                        + t.getMessage());
+              }
+            }
+
+            // Awaits all per-entity update futures before finishing the boot
+            // receiver, bounded by the 8s ANR safety timeout. Any not-yet-
+            // persisted next-fire anchors left behind on timeout will catch up
+            // on the next alarm fire.
+            ListenableFuture<List<Void>> combined = Futures.allAsList(updateFutures);
+            finishReceiverWhenDone(combined, pendingResult, "rescheduleNotifications");
           }
 
           @Override
-          public void onFailure(Throwable t) {
+          public void onFailure(@NonNull Throwable t) {
             Logger.e(TAG, "Failed to reschedule notifications", new Exception(t));
             if (pendingResult != null) {
               pendingResult.finish();