react-native-notify-kit 9.3.0 → 9.5.0

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

@@ -0,0 +1,84 @@
+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.content.Context;
+import android.os.Trace;
+import androidx.core.app.NotificationManagerCompat;
+
+/**
+ * Encapsulates the foreground-service warmup logic so it can be called from both {@link
+ * InitProvider} (automatic, at app startup) and the JS bridge ({@code prewarmForegroundService()},
+ * on-demand).
+ *
+ * <p>This class runs <b>synchronously</b> on the caller's thread. Callers are responsible for
+ * choosing the appropriate thread/executor.
+ *
+ * <p>Safe to call multiple times (idempotent). After the first call, class loading is a no-op from
+ * ART's perspective and the Binder proxy call is cheap.
+ */
+@KeepForSdk
+public final class WarmupHelper {
+
+  private static final String TAG = "WarmupHelper";
+
+  static final String[] WARMUP_CLASSES = {
+    "app.notifee.core.ForegroundService",
+    "app.notifee.core.NotificationManager",
+    "app.notifee.core.model.NotificationModel",
+    "app.notifee.core.model.NotificationAndroidModel",
+    "app.notifee.core.model.ChannelModel",
+    "androidx.core.app.NotificationCompat$Builder",
+    "androidx.core.app.NotificationManagerCompat",
+  };
+
+  private WarmupHelper() {}
+
+  /**
+   * Pre-loads critical foreground-service classes and warms the INotificationManager Binder proxy.
+   * Runs synchronously on the caller's thread.
+   *
+   * @param context Application context used for class loading and Binder warmup.
+   */
+  @KeepForSdk
+  public static void runWarmup(Context context) {
+    Trace.beginSection("notifee:warmup");
+    try {
+      ClassLoader classLoader = context.getClassLoader();
+
+      // Pre-load critical foreground service classes to move ART class loading/verification
+      // cost from the first displayNotification() call to whenever the caller chooses.
+      for (String className : WARMUP_CLASSES) {
+        try {
+          Class.forName(className, true, classLoader);
+        } catch (ClassNotFoundException e) {
+          Logger.d(TAG, "Warmup class not found: " + className);
+        }
+      }
+
+      // Pre-warm INotificationManager Binder proxy by touching NotificationManagerCompat.
+      try {
+        NotificationManagerCompat.from(context).getNotificationChannels();
+      } catch (Exception e) {
+        Logger.d(TAG, "Warmup Binder pre-warm failed: " + e.getMessage());
+      }
+    } finally {
+      Trace.endSection();
+    }
+  }
+}

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));
   }
 }

package/android/src/main/java/app/notifee/core/model/NotificationAndroidModel.java

@@ -74,6 +74,11 @@ public class NotificationAndroidModel {
         Objects.requireNonNull(
             mNotificationAndroidBundle.getParcelableArrayList("foregroundServiceTypes"));
 
+    if (foregroundServiceTypesArrayList.isEmpty()) {
+      Logger.w(TAG, "foregroundServiceTypes is empty; treating as absent");
+      return ServiceInfo.FOREGROUND_SERVICE_TYPE_MANIFEST;
+    }
+
     int foregroundServiceType = 0;
     for (int i = 0; i < foregroundServiceTypesArrayList.size(); i++) {
       foregroundServiceType |= ObjectUtils.getInt(foregroundServiceTypesArrayList.get(i));
@@ -97,6 +102,17 @@ public class NotificationAndroidModel {
     return mNotificationAndroidBundle.getBoolean("asForegroundService", false);
   }
 
+  /**
+   * Gets the foreground service behavior for the notification. Controls whether the foreground
+   * service notification is shown immediately or deferred on Android 12+.
+   *
+   * @return int matching a NotificationCompat.FOREGROUND_SERVICE_* constant
+   */
+  public int getForegroundServiceBehavior() {
+    return mNotificationAndroidBundle.getInt(
+        "foregroundServiceBehavior", NotificationCompat.FOREGROUND_SERVICE_DEFAULT);
+  }
+
   /**
    * Gets if the notification should light up the screen when displayed
    *
@@ -328,7 +344,7 @@ public class NotificationAndroidModel {
 
         return lights;
       } catch (Exception e) {
-        Logger.e(TAG, "getLights -> Failed to parse lights");
+        Logger.e(TAG, "getLights -> Failed to parse lights", e);
         return null;
       }
     }

package/android/src/main/kotlin/io/invertase/notifee/NotifeeApiModule.kt

@@ -317,6 +317,36 @@ class NotifeeApiModule(reactContext: ReactApplicationContext) :
             }
     }
 
+    override fun prewarmForegroundService(promise: Promise) {
+        val context = reactApplicationContext.applicationContext ?: run {
+            promise.reject("ERR_CONTEXT", "ReactApplicationContext is null")
+            return
+        }
+        val executor = java.util.concurrent.Executors.newSingleThreadExecutor { r ->
+            Thread(r, "notifee-prewarm").apply {
+                isDaemon = true
+                priority = Thread.MIN_PRIORITY
+            }
+        }
+        executor.submit {
+            android.os.Trace.beginSection("notifee:prewarm")
+            try {
+                app.notifee.core.WarmupHelper.runWarmup(context)
+                promise.resolve(null)
+            } catch (t: Throwable) {
+                // Best-effort semantics: warmup failures don't reject the promise.
+                // WarmupHelper logs and swallows internal errors; if something
+                // unexpectedly escapes, log it and still resolve so the JS-side
+                // await does not hang.
+                Logger.e("NotifeeApiModule", "prewarmForegroundService unexpectedly threw", t)
+                promise.resolve(null)
+            } finally {
+                android.os.Trace.endSection()
+            }
+        }
+        executor.shutdown()
+    }
+
     override fun hideNotificationDrawer() {
         NotifeeReactUtils.hideNotificationDrawer()
     }

package/android/src/test/java/app/notifee/core/ForegroundServiceTest.java

@@ -0,0 +1,182 @@
+package app.notifee.core;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import android.app.Service;
+import android.content.Intent;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.Robolectric;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.RuntimeEnvironment;
+import org.robolectric.android.controller.ServiceController;
+import org.robolectric.annotation.Config;
+
+@RunWith(RobolectricTestRunner.class)
+public class ForegroundServiceTest {
+
+  @Before
+  public void setUp() {
+    // Initialize ContextHolder so the service can access the application context
+    ContextHolder.setApplicationContext(RuntimeEnvironment.getApplication());
+  }
+
+  @After
+  public void tearDown() {
+    // Reset all accessible static fields to prevent cross-test pollution.
+    // mCurrentNotificationBundle, mCurrentNotification, mCurrentHashCode are private static
+    // and can only be reset via onStartCommand (the STOP path clears them).
+    ForegroundService.mCurrentNotificationId = null;
+    ForegroundService.mCurrentForegroundServiceType = -1;
+  }
+
+  /**
+   * Regression test for Bug #1: a STOP intent arriving on a fresh service instance that has never
+   * called startForeground() must not crash. The defensive startForeground() path should fire,
+   * satisfying Android's contract, and the service should stop cleanly.
+   */
+  @Test
+  public void onStartCommand_stopIntentBeforeStart_doesNotCrash() {
+    ServiceController<ForegroundService> controller =
+        Robolectric.buildService(ForegroundService.class);
+    ForegroundService service = controller.create().get();
+
+    Intent stopIntent = new Intent();
+    stopIntent.setAction(ForegroundService.STOP_FOREGROUND_SERVICE_ACTION);
+
+    // This should not throw — the defensive startForeground() path handles the case
+    int result = service.onStartCommand(stopIntent, 0, 1);
+    assertEquals(Service.START_STICKY_COMPATIBILITY, result);
+  }
+
+  /**
+   * Regression test: a null intent (service recreation after process kill) must not crash. Android
+   * may deliver a null intent when recreating a service.
+   */
+  @Test
+  public void onStartCommand_nullIntent_doesNotCrash() {
+    ServiceController<ForegroundService> controller =
+        Robolectric.buildService(ForegroundService.class);
+    ForegroundService service = controller.create().get();
+
+    // Null intent simulates service recreation after process kill
+    int result = service.onStartCommand(null, 0, 1);
+    assertEquals(Service.START_STICKY_COMPATIBILITY, result);
+  }
+
+  /**
+   * Verifies that after the STOP path, the public static state fields are reset to their initial
+   * values. Only checks the two public static fields (mCurrentNotificationId and
+   * mCurrentForegroundServiceType) — the three private static fields (mCurrentNotificationBundle,
+   * mCurrentNotification, mCurrentHashCode) are not directly accessible from tests.
+   */
+  @Test
+  public void onStartCommand_stopIntent_resetsPublicStaticState() {
+    ServiceController<ForegroundService> controller =
+        Robolectric.buildService(ForegroundService.class);
+    ForegroundService service = controller.create().get();
+
+    // Set some stale state to simulate a prior invocation
+    ForegroundService.mCurrentNotificationId = "test-id";
+    ForegroundService.mCurrentForegroundServiceType = 42;
+
+    Intent stopIntent = new Intent();
+    stopIntent.setAction(ForegroundService.STOP_FOREGROUND_SERVICE_ACTION);
+
+    service.onStartCommand(stopIntent, 0, 1);
+
+    // Public static state should be reset
+    assertEquals(null, ForegroundService.mCurrentNotificationId);
+    assertEquals(-1, ForegroundService.mCurrentForegroundServiceType);
+  }
+
+  /**
+   * Bug A regression: on API 34+ with no foregroundServiceType declared in the manifest, the
+   * defensive STOP path must throw a RuntimeException (causing a crash with an actionable message)
+   * instead of silently catching and proceeding to stopSelf() — which would leave Android's
+   * 5-second startForeground() contract unsatisfied and result in a cryptic ANR.
+   */
+  @Test(expected = RuntimeException.class)
+  @Config(sdk = 34)
+  public void onStartCommand_stopIntentApi34NoManifestType_throwsRuntimeException() {
+    // Robolectric's default shadow PackageManager returns FOREGROUND_SERVICE_TYPE_NONE (0)
+    // for services without an explicit foregroundServiceType in the test manifest.
+    ServiceController<ForegroundService> controller =
+        Robolectric.buildService(ForegroundService.class);
+    ForegroundService service = controller.create().get();
+
+    Intent stopIntent = new Intent();
+    stopIntent.setAction(ForegroundService.STOP_FOREGROUND_SERVICE_ACTION);
+    service.onStartCommand(stopIntent, 0, 1);
+  }
+
+  /**
+   * Bug A regression: the RuntimeException message must contain the documentation URL so the
+   * developer debugging the crash can find the fix immediately.
+   */
+  @Test
+  @Config(sdk = 34)
+  public void onStartCommand_stopIntentApi34NoManifestType_messageContainsDocUrl() {
+    ServiceController<ForegroundService> controller =
+        Robolectric.buildService(ForegroundService.class);
+    ForegroundService service = controller.create().get();
+
+    Intent stopIntent = new Intent();
+    stopIntent.setAction(ForegroundService.STOP_FOREGROUND_SERVICE_ACTION);
+    try {
+      service.onStartCommand(stopIntent, 0, 1);
+      fail("Expected RuntimeException");
+    } catch (RuntimeException e) {
+      assertTrue(
+          "Message should contain documentation URL",
+          e.getMessage().contains("foreground-service-setup-android-14"));
+    }
+  }
+
+  /**
+   * Backward compatibility: on API levels below 34, the defensive path should run normally without
+   * the proactive manifest check. No foregroundServiceType declaration is required pre-API 34.
+   */
+  @Test
+  @Config(sdk = 33)
+  public void onStartCommand_stopIntentApiBelow34_defensivePathRunsNormally() {
+    ServiceController<ForegroundService> controller =
+        Robolectric.buildService(ForegroundService.class);
+    ForegroundService service = controller.create().get();
+
+    Intent stopIntent = new Intent();
+    stopIntent.setAction(ForegroundService.STOP_FOREGROUND_SERVICE_ACTION);
+
+    // Should not throw on API 33, regardless of manifest
+    int result = service.onStartCommand(stopIntent, 0, 1);
+    assertEquals(Service.START_STICKY_COMPATIBILITY, result);
+  }
+
+  /**
+   * Idempotency: when mStartForegroundCalled is already true (the service has previously called
+   * startForeground() successfully), the helper must be a no-op. Verified by sending two
+   * consecutive STOP intents — the second should not crash even on API 33 where the first succeeded
+   * via the defensive path.
+   */
+  @Test
+  @Config(sdk = 33)
+  public void onStartCommand_stopIntentAfterSuccessfulStart_skipsDefensivePath() {
+    ServiceController<ForegroundService> controller =
+        Robolectric.buildService(ForegroundService.class);
+    ForegroundService service = controller.create().get();
+
+    Intent stopIntent = new Intent();
+    stopIntent.setAction(ForegroundService.STOP_FOREGROUND_SERVICE_ACTION);
+
+    // First STOP — triggers defensive startForeground
+    service.onStartCommand(stopIntent, 0, 1);
+
+    // Second STOP — helper should be no-op since mStartForegroundCalled is now true
+    int result = service.onStartCommand(stopIntent, 0, 2);
+    assertEquals(Service.START_STICKY_COMPATIBILITY, result);
+  }
+}