react-native-notify-kit 9.4.0 → 9.5.0

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

@@ -543,15 +543,13 @@ class NotificationManager {
             task -> {
               if (notificationType == NOTIFICATION_TYPE_TRIGGER
                   || notificationType == NOTIFICATION_TYPE_ALL) {
-                return new ExtendedListenableFuture<Void>(
-                        NotifeeAlarmManager.cancelAllNotifications())
-                    .addOnCompleteListener(
-                        (e, result) -> {
-                          if (e == null) {
-                            WorkDataRepository.getInstance(getApplicationContext()).deleteAll();
-                          }
-                        },
-                        LISTENING_CACHED_THREAD_POOL);
+                // Chain the Room delete onto the alarm-manager cancel so the outer
+                // future — and therefore the JS Promise — only completes after Room
+                // has drained. Fixes upstream invertase/notifee#549.
+                return Futures.transformAsync(
+                    NotifeeAlarmManager.cancelAllNotifications(),
+                    ignored -> WorkDataRepository.getInstance(getApplicationContext()).deleteAll(),
+                    LISTENING_CACHED_THREAD_POOL);
               }
               return Futures.immediateFuture(null);
             },
@@ -613,9 +611,11 @@ class NotificationManager {
                 }))
         .continueWith(
             task -> {
-              // delete all from database
+              // Chain the Room delete so the outer future — and therefore the JS
+              // Promise — only completes after Room has drained. Fixes upstream
+              // invertase/notifee#549 for the per-id cancel path.
               if (notificationType != NOTIFICATION_TYPE_DISPLAYED) {
-                WorkDataRepository.getInstance(getApplicationContext()).deleteByIds(ids);
+                return WorkDataRepository.getInstance(getApplicationContext()).deleteByIds(ids);
               }
               return Futures.immediateFuture(null);
             },
@@ -691,56 +691,75 @@ class NotificationManager {
 
   static ListenableFuture<Void> createTriggerNotification(
       NotificationModel notificationModel, Bundle triggerBundle) {
-    return LISTENING_CACHED_THREAD_POOL.submit(
-        () -> {
-          int triggerType = ObjectUtils.getInt(triggerBundle.get("type"));
-          switch (triggerType) {
-            case 0:
-              createTimestampTriggerNotification(notificationModel, triggerBundle);
-              break;
-            case 1:
-              createIntervalTriggerNotification(notificationModel, triggerBundle);
-              break;
-          }
+    int triggerType = ObjectUtils.getInt(triggerBundle.get("type"));
+    ListenableFuture<Void> scheduleFuture;
+    switch (triggerType) {
+      case 0:
+        scheduleFuture = createTimestampTriggerNotification(notificationModel, triggerBundle);
+        break;
+      case 1:
+        scheduleFuture = createIntervalTriggerNotification(notificationModel, triggerBundle);
+        break;
+      default:
+        scheduleFuture = Futures.immediateFuture(null);
+        break;
+    }
 
+    return Futures.transform(
+        scheduleFuture,
+        unused -> {
           EventBus.post(
               new NotificationEvent(
                   NotificationEvent.TYPE_TRIGGER_NOTIFICATION_CREATED, notificationModel));
-
           return null;
-        });
+        },
+        LISTENING_CACHED_THREAD_POOL);
   }
 
-  static void createIntervalTriggerNotification(
+  // Returns a future that completes only after the Room insert has persisted AND
+  // WorkManager has enqueued the periodic work. Chaining Room-first guarantees the
+  // worker reads the row on its first fire even if the process is killed between
+  // the JS Promise resolving and WorkManager scheduling. Fixes upstream
+  // invertase/notifee#549 for the interval-trigger path.
+  static ListenableFuture<Void> createIntervalTriggerNotification(
       NotificationModel notificationModel, Bundle triggerBundle) {
     IntervalTriggerModel trigger = IntervalTriggerModel.fromBundle(triggerBundle);
     String uniqueWorkName = "trigger:" + notificationModel.getId();
-    WorkManager workManager = WorkManager.getInstance(getApplicationContext());
-
-    Data.Builder workDataBuilder =
-        new Data.Builder()
-            .putString(Worker.KEY_WORK_TYPE, Worker.WORK_TYPE_NOTIFICATION_TRIGGER)
-            .putString(Worker.KEY_WORK_REQUEST, Worker.WORK_REQUEST_PERIODIC)
-            .putString("id", notificationModel.getId());
-
-    WorkDataRepository.getInstance(getApplicationContext())
-        .insertTriggerNotification(notificationModel, triggerBundle, false);
-
-    long interval = trigger.getInterval();
-
-    PeriodicWorkRequest.Builder workRequestBuilder;
-    workRequestBuilder =
-        new PeriodicWorkRequest.Builder(Worker.class, interval, trigger.getTimeUnit())
-            .setInitialDelay(interval, trigger.getTimeUnit());
-
-    workRequestBuilder.addTag(Worker.WORK_TYPE_NOTIFICATION_TRIGGER);
-    workRequestBuilder.addTag(uniqueWorkName);
-    workRequestBuilder.setInputData(workDataBuilder.build());
-    workManager.enqueueUniquePeriodicWork(
-        uniqueWorkName, ExistingPeriodicWorkPolicy.UPDATE, workRequestBuilder.build());
+    Context context = getApplicationContext();
+
+    ListenableFuture<Void> insertFuture =
+        WorkDataRepository.insertTriggerNotification(
+            context, notificationModel, triggerBundle, false);
+
+    return Futures.transform(
+        insertFuture,
+        unused -> {
+          WorkManager workManager = WorkManager.getInstance(context);
+          Data.Builder workDataBuilder =
+              new Data.Builder()
+                  .putString(Worker.KEY_WORK_TYPE, Worker.WORK_TYPE_NOTIFICATION_TRIGGER)
+                  .putString(Worker.KEY_WORK_REQUEST, Worker.WORK_REQUEST_PERIODIC)
+                  .putString("id", notificationModel.getId());
+
+          long interval = trigger.getInterval();
+          PeriodicWorkRequest.Builder workRequestBuilder =
+              new PeriodicWorkRequest.Builder(Worker.class, interval, trigger.getTimeUnit())
+                  .setInitialDelay(interval, trigger.getTimeUnit());
+          workRequestBuilder.addTag(Worker.WORK_TYPE_NOTIFICATION_TRIGGER);
+          workRequestBuilder.addTag(uniqueWorkName);
+          workRequestBuilder.setInputData(workDataBuilder.build());
+          workManager.enqueueUniquePeriodicWork(
+              uniqueWorkName, ExistingPeriodicWorkPolicy.UPDATE, workRequestBuilder.build());
+          return null;
+        },
+        LISTENING_CACHED_THREAD_POOL);
   }
 
-  static void createTimestampTriggerNotification(
+  // Returns a future that completes only after the Room insert has persisted AND
+  // the AlarmManager / WorkManager schedule call has run. Same rationale as the
+  // interval path above. Fixes upstream invertase/notifee#549 for the timestamp
+  // trigger path (AlarmManager by default since 9.1.12).
+  static ListenableFuture<Void> createTimestampTriggerNotification(
       NotificationModel notificationModel, Bundle triggerBundle) {
     TimestampTriggerModel trigger = TimestampTriggerModel.fromBundle(triggerBundle);
 
@@ -749,52 +768,56 @@ class NotificationManager {
     long delay = trigger.getDelay();
     int interval = trigger.getInterval();
 
-    // Save in DB
     Data.Builder workDataBuilder =
         new Data.Builder()
             .putString(Worker.KEY_WORK_TYPE, Worker.WORK_TYPE_NOTIFICATION_TRIGGER)
             .putString("id", notificationModel.getId());
 
     Boolean withAlarmManager = trigger.getWithAlarmManager();
+    Context context = getApplicationContext();
+
+    ListenableFuture<Void> insertFuture =
+        WorkDataRepository.insertTriggerNotification(
+            context, notificationModel, triggerBundle, withAlarmManager);
+
+    return Futures.transform(
+        insertFuture,
+        unused -> {
+          if (withAlarmManager) {
+            NotifeeAlarmManager.scheduleTimestampTriggerNotification(notificationModel, trigger);
+            return null;
+          }
 
-    WorkDataRepository.getInstance(getApplicationContext())
-        .insertTriggerNotification(notificationModel, triggerBundle, withAlarmManager);
-
-    // Schedule notification with alarm manager
-    if (withAlarmManager) {
-      NotifeeAlarmManager.scheduleTimestampTriggerNotification(notificationModel, trigger);
-      return;
-    }
-
-    // Continue to schedule trigger notification with WorkManager
-    WorkManager workManager = WorkManager.getInstance(getApplicationContext());
-
-    // WorkManager - One time trigger
-    if (interval == -1) {
-      OneTimeWorkRequest.Builder workRequestBuilder = new OneTimeWorkRequest.Builder(Worker.class);
-      workRequestBuilder.addTag(Worker.WORK_TYPE_NOTIFICATION_TRIGGER);
-      workRequestBuilder.addTag(uniqueWorkName);
-      workDataBuilder.putString(Worker.KEY_WORK_REQUEST, Worker.WORK_REQUEST_ONE_TIME);
-      workRequestBuilder.setInputData(workDataBuilder.build());
-      workRequestBuilder.setInitialDelay(delay, TimeUnit.SECONDS);
-      workManager.enqueueUniqueWork(
-          uniqueWorkName, ExistingWorkPolicy.REPLACE, workRequestBuilder.build());
-    } else {
-      // WorkManager - repeat trigger
-      PeriodicWorkRequest.Builder workRequestBuilder;
-
-      workRequestBuilder =
-          new PeriodicWorkRequest.Builder(
-              Worker.class, trigger.getInterval(), trigger.getTimeUnit());
-
-      workRequestBuilder.addTag(Worker.WORK_TYPE_NOTIFICATION_TRIGGER);
-      workRequestBuilder.addTag(uniqueWorkName);
-      workRequestBuilder.setInitialDelay(delay, TimeUnit.SECONDS);
-      workDataBuilder.putString(Worker.KEY_WORK_REQUEST, Worker.WORK_REQUEST_PERIODIC);
-      workRequestBuilder.setInputData(workDataBuilder.build());
-      workManager.enqueueUniquePeriodicWork(
-          uniqueWorkName, ExistingPeriodicWorkPolicy.UPDATE, workRequestBuilder.build());
-    }
+          WorkManager workManager = WorkManager.getInstance(context);
+
+          // WorkManager - One time trigger
+          if (interval == -1) {
+            OneTimeWorkRequest.Builder workRequestBuilder =
+                new OneTimeWorkRequest.Builder(Worker.class);
+            workRequestBuilder.addTag(Worker.WORK_TYPE_NOTIFICATION_TRIGGER);
+            workRequestBuilder.addTag(uniqueWorkName);
+            workDataBuilder.putString(Worker.KEY_WORK_REQUEST, Worker.WORK_REQUEST_ONE_TIME);
+            workRequestBuilder.setInputData(workDataBuilder.build());
+            workRequestBuilder.setInitialDelay(delay, TimeUnit.SECONDS);
+            workManager.enqueueUniqueWork(
+                uniqueWorkName, ExistingWorkPolicy.REPLACE, workRequestBuilder.build());
+          } else {
+            // WorkManager - repeat trigger
+            PeriodicWorkRequest.Builder workRequestBuilder =
+                new PeriodicWorkRequest.Builder(
+                    Worker.class, trigger.getInterval(), trigger.getTimeUnit());
+
+            workRequestBuilder.addTag(Worker.WORK_TYPE_NOTIFICATION_TRIGGER);
+            workRequestBuilder.addTag(uniqueWorkName);
+            workRequestBuilder.setInitialDelay(delay, TimeUnit.SECONDS);
+            workDataBuilder.putString(Worker.KEY_WORK_REQUEST, Worker.WORK_REQUEST_PERIODIC);
+            workRequestBuilder.setInputData(workDataBuilder.build());
+            workManager.enqueueUniquePeriodicWork(
+                uniqueWorkName, ExistingPeriodicWorkPolicy.UPDATE, workRequestBuilder.build());
+          }
+          return null;
+        },
+        LISTENING_CACHED_THREAD_POOL);
   }
 
   static ListenableFuture<List<Bundle>> getDisplayedNotifications() {
@@ -982,17 +1005,51 @@ class NotificationManager {
                 new ExtendedListenableFuture<>(result)
                     .addOnCompleteListener(
                         (e2, _unused) -> {
-                          completer.set(Result.success());
                           if (e2 != null) {
                             Logger.e(TAG, "Failed to display notification", e2);
+                            completer.set(Result.success());
+                            return;
+                          }
+                          String workerRequestType = data.getString(Worker.KEY_WORK_REQUEST);
+                          if (workerRequestType != null
+                              && workerRequestType.equals(Worker.WORK_REQUEST_ONE_TIME)) {
+                            // DO NOT reorder — completer.set must only run after the
+                            // delete future completes, otherwise WorkManager may start
+                            // a new work instance that reads the stale row. Previously
+                            // completer.set fired before the delete was enqueued, leaving
+                            // a zombie row that reboot recovery would resurrect as a
+                            // ghost alarm. See #549 audit Part B, Caller #5.
+                            //
+                            // Note: CallbackToFutureAdapter.Completer.set() returns
+                            // false on double-set, it does NOT throw. This is an
+                            // androidx contract. Do not refactor under the assumption
+                            // that double-set is dangerous.
+                            Futures.addCallback(
+                                WorkDataRepository.getInstance(getApplicationContext())
+                                    .deleteById(id),
+                                new FutureCallback<Void>() {
+                                  @Override
+                                  public void onSuccess(Void unused) {
+                                    completer.set(Result.success());
+                                  }
+
+                                  @Override
+                                  public void onFailure(@NonNull Throwable t) {
+                                    // Notification was already displayed; a failed
+                                    // delete leaves an orphan row that the next
+                                    // cancelAll or app restart will clean up. Still
+                                    // report success so WorkManager doesn't retry
+                                    // the already-displayed notification.
+                                    Logger.e(
+                                        TAG,
+                                        "Failed to delete one-time trigger row after" + " display",
+                                        new Exception(t));
+                                    completer.set(Result.success());
+                                  }
+                                },
+                                LISTENING_CACHED_THREAD_POOL);
                           } else {
-                            String workerRequestType = data.getString(Worker.KEY_WORK_REQUEST);
-                            if (workerRequestType != null
-                                && workerRequestType.equals(Worker.WORK_REQUEST_ONE_TIME)) {
-                              // delete database entry if work is a one-time request
-                              WorkDataRepository.getInstance(getApplicationContext())
-                                  .deleteById(id);
-                            }
+                            completer.set(Result.success());
                           }
                         },
                         LISTENING_CACHED_THREAD_POOL);

package/android/src/main/java/app/notifee/core/database/WorkDataRepository.java

@@ -20,13 +20,16 @@ package app.notifee.core.database;
 import android.content.Context;
 import android.os.Bundle;
 import androidx.annotation.NonNull;
+import androidx.annotation.VisibleForTesting;
 import app.notifee.core.model.NotificationModel;
 import app.notifee.core.utility.ObjectUtils;
 import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
 import java.util.List;
 
 public class WorkDataRepository {
-  private WorkDataDao mWorkDataDao;
+  private final WorkDataDao mWorkDataDao;
+  private final ListeningExecutorService mExecutor;
   private static WorkDataRepository mInstance;
 
   public static @NonNull WorkDataRepository getInstance(@NonNull Context context) {
@@ -42,52 +45,56 @@ public class WorkDataRepository {
   public WorkDataRepository(Context context) {
     NotifeeCoreDatabase db = NotifeeCoreDatabase.getDatabase(context);
     mWorkDataDao = db.workDao();
+    mExecutor = NotifeeCoreDatabase.databaseWriteListeningExecutor;
   }
 
-  public void insert(WorkDataEntity workData) {
-    NotifeeCoreDatabase.databaseWriteListeningExecutor.execute(
-        () -> {
-          mWorkDataDao.insert(workData);
-        });
+  @VisibleForTesting
+  WorkDataRepository(@NonNull WorkDataDao dao, @NonNull ListeningExecutorService executor) {
+    mWorkDataDao = dao;
+    mExecutor = executor;
+  }
+
+  // Submit a DAO write to the listening executor and return a future that
+  // completes when the DAO call returns (success or exception). Using the
+  // submit(Runnable, result) overload avoids the Callable<Object> inference
+  // that would otherwise require a cast at every call site.
+  private @NonNull ListenableFuture<Void> submitWrite(@NonNull Runnable work) {
+    return mExecutor.submit(work, (Void) null);
+  }
+
+  public @NonNull ListenableFuture<Void> insert(WorkDataEntity workData) {
+    return submitWrite(() -> mWorkDataDao.insert(workData));
   }
 
   public ListenableFuture<WorkDataEntity> getWorkDataById(String id) {
-    return NotifeeCoreDatabase.databaseWriteListeningExecutor.submit(
-        () -> mWorkDataDao.getWorkDataById(id));
+    return mExecutor.submit(() -> mWorkDataDao.getWorkDataById(id));
   }
 
   public ListenableFuture<List<WorkDataEntity>> getAllWithAlarmManager(Boolean withAlarmManager) {
-    return NotifeeCoreDatabase.databaseWriteListeningExecutor.submit(
-        () -> mWorkDataDao.getAllWithAlarmManager(withAlarmManager));
+    return mExecutor.submit(() -> mWorkDataDao.getAllWithAlarmManager(withAlarmManager));
   }
 
   public ListenableFuture<List<WorkDataEntity>> getAll() {
-    return NotifeeCoreDatabase.databaseWriteListeningExecutor.submit(() -> mWorkDataDao.getAll());
+    return mExecutor.submit(() -> mWorkDataDao.getAll());
   }
 
-  public void deleteById(String id) {
-    NotifeeCoreDatabase.databaseWriteListeningExecutor.execute(
-        () -> {
-          mWorkDataDao.deleteById(id);
-        });
+  public @NonNull ListenableFuture<Void> deleteById(String id) {
+    return submitWrite(() -> mWorkDataDao.deleteById(id));
   }
 
-  public void deleteByIds(List<String> ids) {
-    NotifeeCoreDatabase.databaseWriteListeningExecutor.execute(
-        () -> {
-          mWorkDataDao.deleteByIds(ids);
-        });
+  public @NonNull ListenableFuture<Void> deleteByIds(List<String> ids) {
+    return submitWrite(() -> mWorkDataDao.deleteByIds(ids));
   }
 
-  public void deleteAll() {
-    NotifeeCoreDatabase.databaseWriteListeningExecutor.execute(
-        () -> {
-          mWorkDataDao.deleteAll();
-        });
+  public @NonNull ListenableFuture<Void> deleteAll() {
+    return submitWrite(() -> mWorkDataDao.deleteAll());
   }
 
-  public static void insertTriggerNotification(
-      NotificationModel notificationModel, Bundle triggerBundle, Boolean withAlarmManager) {
+  public static @NonNull ListenableFuture<Void> insertTriggerNotification(
+      @NonNull Context context,
+      NotificationModel notificationModel,
+      Bundle triggerBundle,
+      Boolean withAlarmManager) {
     WorkDataEntity workData =
         new WorkDataEntity(
             notificationModel.getId(),
@@ -95,13 +102,10 @@ public class WorkDataRepository {
             ObjectUtils.bundleToBytes(triggerBundle),
             withAlarmManager);
 
-    mInstance.insert(workData);
+    return getInstance(context).insert(workData);
   }
 
-  public void update(WorkDataEntity workData) {
-    NotifeeCoreDatabase.databaseWriteListeningExecutor.execute(
-        () -> {
-          mWorkDataDao.update(workData);
-        });
+  public @NonNull ListenableFuture<Void> update(WorkDataEntity workData) {
+    return submitWrite(() -> mWorkDataDao.update(workData));
   }
 }