react-native-notify-kit 9.4.0 → 9.6.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/AlarmPermissionBroadcastReceiver.java

@@ -5,21 +5,32 @@ import static android.app.AlarmManager.ACTION_SCHEDULE_EXACT_ALARM_PERMISSION_ST
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
-import android.util.Log;
 
 public class AlarmPermissionBroadcastReceiver extends BroadcastReceiver {
+  private static final String TAG = "AlarmPermissionReceiver";
+
   @Override
   public void onReceive(Context context, Intent intent) {
+    if (!ACTION_SCHEDULE_EXACT_ALARM_PERMISSION_STATE_CHANGED.equals(intent.getAction())) {
+      return;
+    }
 
-    if (intent.getAction().equals(ACTION_SCHEDULE_EXACT_ALARM_PERMISSION_STATE_CHANGED)) {
-      PendingResult pendingResult = goAsync();
-      Log.i("AlarmPermissionReceiver", "Received alarm permission state changed event");
-
+    PendingResult pendingResult = goAsync();
+    // See RebootBroadcastReceiver for the rationale behind this guard.
+    boolean asyncHandoffSucceeded = false;
+    try {
+      Logger.i(TAG, "Received alarm permission state changed event");
       if (ContextHolder.getApplicationContext() == null) {
         ContextHolder.setApplicationContext(context.getApplicationContext());
       }
-
       new NotifeeAlarmManager().rescheduleNotifications(pendingResult);
+      asyncHandoffSucceeded = true;
+    } catch (Throwable t) {
+      Logger.e(TAG, "Failed to reschedule notifications after permission change", t);
+    } finally {
+      if (!asyncHandoffSucceeded && pendingResult != null) {
+        pendingResult.finish();
+      }
     }
   }
 }

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

@@ -26,9 +26,11 @@ import android.content.pm.ProviderInfo;
 import android.database.Cursor;
 import android.net.Uri;
 import android.os.Trace;
+import android.provider.Settings;
 import androidx.annotation.CallSuper;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
+import androidx.annotation.VisibleForTesting;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 
@@ -64,8 +66,15 @@ public class InitProvider extends ContentProvider {
       }
 
       Context appContext = ContextHolder.getApplicationContext();
-      if (appContext != null && isWarmupEnabled(appContext)) {
-        dispatchWarmup(appContext);
+      if (appContext != null) {
+        if (isWarmupEnabled(appContext)) {
+          dispatchWarmup(appContext);
+        }
+        // Fix for upstream invertase/notifee#734: recover scheduled alarms on every app init
+        // when a reboot has occurred since the last run. Runs unconditionally (not gated by
+        // the warmup metadata flag) because this is recovery, not optimisation. Always on a
+        // background thread to keep app startup clean.
+        dispatchBootCheck(appContext);
       }
     } finally {
       Trace.endSection();
@@ -100,6 +109,104 @@ public class InitProvider extends ContentProvider {
     executor.shutdown();
   }
 
+  /**
+   * Dispatches the BOOT_COUNT cold-start recovery check on a background thread. Mirrors {@link
+   * #dispatchWarmup} so that app startup stays free of I/O. Fix for upstream invertase/notifee#734.
+   */
+  private static void dispatchBootCheck(final Context context) {
+    ExecutorService executor =
+        Executors.newSingleThreadExecutor(
+            r -> {
+              Thread t = new Thread(r, "notifee-boot-check");
+              t.setDaemon(true);
+              t.setPriority(Thread.MIN_PRIORITY);
+              return t;
+            });
+
+    executor.submit(() -> runBootCheck(context));
+    executor.shutdown();
+  }
+
+  /**
+   * Reads {@code Settings.Global.BOOT_COUNT} and compares it against the last-known value stored in
+   * {@link Preferences}. If a reboot has occurred since the last app run — or if BOOT_COUNT cannot
+   * be read (custom ROMs, emulators, exotic vendors) — invokes {@link
+   * NotifeeAlarmManager#rescheduleNotifications(android.content.BroadcastReceiver.PendingResult)}
+   * to recover any AlarmManager triggers that may not have been re-armed by {@code
+   * RebootBroadcastReceiver} on OEM devices that suppress {@code BOOT_COMPLETED}.
+   *
+   * <p>Package-private for direct invocation from Robolectric unit tests.
+   */
+  static void runBootCheck(Context context) {
+    try {
+      int currentBootCount = readBootCount(context);
+      int lastKnownBootCount =
+          Preferences.getSharedInstance().getIntValue(Preferences.LAST_KNOWN_BOOT_COUNT_KEY, -1);
+
+      boolean shouldReschedule = shouldRescheduleAfterBoot(currentBootCount, lastKnownBootCount);
+
+      if (currentBootCount == -1 && lastKnownBootCount == -1) {
+        Logger.i(TAG, "BOOT_COUNT unavailable on first run; running conservative reschedule");
+      } else if (currentBootCount == -1) {
+        Logger.i(TAG, "BOOT_COUNT unavailable; running conservative reschedule to be safe");
+      } else if (lastKnownBootCount == -1) {
+        Logger.i(TAG, "First run: recording BOOT_COUNT baseline " + currentBootCount);
+      } else if (currentBootCount != lastKnownBootCount) {
+        Logger.i(
+            TAG,
+            "Boot detected since last run ("
+                + lastKnownBootCount
+                + " -> "
+                + currentBootCount
+                + "), rescheduling");
+      }
+
+      // Only persist real values. Writing -1 would erase a prior real baseline
+      // and cause every subsequent init to run a conservative reschedule.
+      if (currentBootCount != -1) {
+        Preferences.getSharedInstance()
+            .setIntValue(Preferences.LAST_KNOWN_BOOT_COUNT_KEY, currentBootCount);
+      }
+
+      if (shouldReschedule) {
+        new NotifeeAlarmManager().rescheduleNotifications(null);
+      }
+    } catch (Throwable t) {
+      Logger.e(TAG, "Cold-start reschedule check failed", t);
+    }
+  }
+
+  private static int readBootCount(Context context) {
+    try {
+      return Settings.Global.getInt(context.getContentResolver(), Settings.Global.BOOT_COUNT, -1);
+    } catch (Throwable t) {
+      Logger.w(TAG, "Failed to read Settings.Global.BOOT_COUNT", t);
+      return -1;
+    }
+  }
+
+  /**
+   * Pure decision function for BOOT_COUNT-based cold-start recovery. Returns {@code true} when the
+   * current init should trigger a reschedule pass, {@code false} otherwise.
+   *
+   * <ul>
+   *   <li>{@code currentBootCount == -1} → BOOT_COUNT unavailable; reschedule conservatively.
+   *   <li>{@code lastKnownBootCount == -1} → first run; record baseline without rescheduling.
+   *   <li>{@code currentBootCount != lastKnownBootCount} → reboot detected; reschedule.
+   *   <li>Otherwise → same boot as last run; no-op.
+   * </ul>
+   */
+  @VisibleForTesting
+  static boolean shouldRescheduleAfterBoot(int currentBootCount, int lastKnownBootCount) {
+    if (currentBootCount == -1) {
+      return true;
+    }
+    if (lastKnownBootCount == -1) {
+      return false;
+    }
+    return currentBootCount != lastKnownBootCount;
+  }
+
   @Nullable
   @Override
   public Cursor query(