react-native-notify-kit 9.3.0 → 9.5.0

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

@@ -19,6 +19,8 @@ package app.notifee.core;
 
 import android.annotation.SuppressLint;
 import android.app.Notification;
+import android.app.NotificationChannel;
+import android.app.NotificationManager;
 import android.app.Service;
 import android.content.ComponentName;
 import android.content.Context;
@@ -28,8 +30,10 @@ import android.content.pm.ServiceInfo;
 import android.os.Build;
 import android.os.Bundle;
 import android.os.IBinder;
+import android.os.Trace;
 import androidx.annotation.Nullable;
 import androidx.annotation.RequiresApi;
+import androidx.core.app.NotificationCompat;
 import androidx.core.app.NotificationManagerCompat;
 import app.notifee.core.event.ForegroundServiceEvent;
 import app.notifee.core.event.NotificationEvent;
@@ -44,6 +48,19 @@ public class ForegroundService extends Service {
       "app.notifee.core.ForegroundService.STOP";
 
   private static final Object sLock = new Object();
+  private static final String DEFENSIVE_CHANNEL_ID = "notifee_fg_default";
+  private static final int DEFENSIVE_NOTIFICATION_ID = Integer.MAX_VALUE - 1;
+
+  /**
+   * Tracks whether startForeground() has been called on THIS service instance. This is an instance
+   * field (not static) because the static fields below track cross-invocation notification state
+   * shared across the process lifetime, but mStartForegroundCalled must track whether this specific
+   * service instance — which may be a fresh recreation after process death — has fulfilled
+   * Android's startForeground() contract. If the process is killed and Android recreates the
+   * service, all statics reset AND a new instance is created; we need per-instance tracking to know
+   * whether the recreated instance has called startForeground() before attempting stopSelf().
+   */
+  private volatile boolean mStartForegroundCalled = false;
 
   public static String mCurrentNotificationId = null;
 
@@ -133,6 +150,11 @@ public class ForegroundService extends Service {
       // Call start service first with stop action
       context.startService(intent);
     } catch (IllegalStateException illegalStateException) {
+      Logger.w(
+          TAG,
+          "startService() threw IllegalStateException on STOP path;"
+              + " falling back to stopService()",
+          illegalStateException);
       // try to stop with stopService command
       context.stopService(intent);
     } catch (Exception exception) {
@@ -143,78 +165,43 @@ public class ForegroundService extends Service {
   @SuppressLint({"ForegroundServiceType", "MissingPermission"})
   @Override
   public int onStartCommand(Intent intent, int flags, int startId) {
-    // Check if action is to stop the foreground service
-    if (intent == null || STOP_FOREGROUND_SERVICE_ACTION.equals(intent.getAction())) {
-      stopSelf();
-      synchronized (sLock) {
-        mCurrentNotificationId = null;
-        mCurrentForegroundServiceType = -1;
-        mCurrentNotificationBundle = null;
-        mCurrentNotification = null;
-        mCurrentHashCode = 0;
+    Trace.beginSection("notifee:ForegroundService.onStartCommand");
+    try {
+      // Check if action is to stop the foreground service
+      if (intent == null || STOP_FOREGROUND_SERVICE_ACTION.equals(intent.getAction())) {
+        ensureStartForegroundContractSatisfied();
+        stopSelf();
+        synchronized (sLock) {
+          mCurrentNotificationId = null;
+          mCurrentForegroundServiceType = -1;
+          mCurrentNotificationBundle = null;
+          mCurrentNotification = null;
+          mCurrentHashCode = 0;
+        }
+        return Service.START_STICKY_COMPATIBILITY;
       }
-      return Service.START_STICKY_COMPATIBILITY;
-    }
-
-    Bundle extras = intent.getExtras();
 
-    if (extras != null) {
-      // Hash code is sent to service to ensure it is kept the same
-      int hashCode = extras.getInt("hashCode");
-      Notification notification = extras.getParcelable("notification");
-      Bundle bundle = extras.getBundle("notificationBundle");
+      Bundle extras = intent.getExtras();
 
-      if (notification != null && bundle != null) {
-        NotificationModel notificationModel = NotificationModel.fromBundle(bundle);
+      if (extras != null) {
+        // Hash code is sent to service to ensure it is kept the same
+        int hashCode = extras.getInt("hashCode");
+        Notification notification = extras.getParcelable("notification");
+        Bundle bundle = extras.getBundle("notificationBundle");
 
-        Object pendingEvent = null;
+        if (notification != null && bundle != null) {
+          NotificationModel notificationModel = NotificationModel.fromBundle(bundle);
 
-        synchronized (sLock) {
-          if (mCurrentNotificationId == null) {
-            mCurrentNotificationId = notificationModel.getId();
-            mCurrentNotificationBundle = bundle;
-            mCurrentNotification = notification;
-            mCurrentHashCode = hashCode;
-
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-              int foregroundServiceType = notificationModel.getAndroid().getForegroundServiceType();
-              if (foregroundServiceType == ServiceInfo.FOREGROUND_SERVICE_TYPE_MANIFEST) {
-                foregroundServiceType = resolveManifestServiceType();
-              }
-              if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE
-                  && foregroundServiceType == ServiceInfo.FOREGROUND_SERVICE_TYPE_NONE) {
-                Logger.e(
-                    TAG,
-                    "Resolved foreground service type is NONE on API 34+; aborting"
-                        + " startForeground to avoid InvalidForegroundServiceTypeException.");
-                mCurrentNotificationId = null;
-                mCurrentNotificationBundle = null;
-                return START_NOT_STICKY;
-              }
-              startForeground(hashCode, notification, foregroundServiceType);
-              mCurrentForegroundServiceType = foregroundServiceType;
-            } else {
-              startForeground(hashCode, notification);
-            }
+          Object pendingEvent = null;
+          boolean noneEarlyReturn = false;
 
-            // On headless task complete
-            final MethodCallResult<Void> methodCallResult =
-                (e, aVoid) -> {
-                  stopForegroundCompat();
-                  synchronized (sLock) {
-                    mCurrentNotificationId = null;
-                    mCurrentForegroundServiceType = -1;
-                    mCurrentNotificationBundle = null;
-                    mCurrentNotification = null;
-                    mCurrentHashCode = 0;
-                  }
-                };
+          synchronized (sLock) {
+            if (mCurrentNotificationId == null) {
+              mCurrentNotificationId = notificationModel.getId();
+              mCurrentNotificationBundle = bundle;
+              mCurrentNotification = notification;
+              mCurrentHashCode = hashCode;
 
-            pendingEvent = new ForegroundServiceEvent(notificationModel, methodCallResult);
-          } else {
-            if (mCurrentNotificationId.equals(notificationModel.getId())) {
-              boolean shouldPostNotificationAgain = true;
-              // find if we need to start the service again if the type was changed
               if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
                 int foregroundServiceType =
                     notificationModel.getAndroid().getForegroundServiceType();
@@ -225,32 +212,110 @@ public class ForegroundService extends Service {
                     && foregroundServiceType == ServiceInfo.FOREGROUND_SERVICE_TYPE_NONE) {
                   Logger.e(
                       TAG,
-                      "Resolved foreground service type is NONE on API 34+; skipping type"
-                          + " change.");
-                } else if (foregroundServiceType != mCurrentForegroundServiceType) {
-                  startForeground(hashCode, notification, foregroundServiceType);
+                      "Resolved foreground service type is NONE on API 34+; aborting"
+                          + " startForeground to avoid InvalidForegroundServiceTypeException.");
+                  // Reset stale state while still holding the lock.
+                  mCurrentNotificationId = null;
+                  mCurrentForegroundServiceType = -1;
+                  mCurrentNotificationBundle = null;
+                  mCurrentNotification = null;
+                  mCurrentHashCode = 0;
+                  // Set flag to call the helper AFTER releasing sLock — it performs
+                  // Binder IPC (PackageManager + startForeground) and must not hold sLock.
+                  noneEarlyReturn = true;
+                } else {
+                  Trace.beginSection("notifee:startForeground");
+                  try {
+                    startForeground(hashCode, notification, foregroundServiceType);
+                  } finally {
+                    Trace.endSection();
+                  }
+                  mStartForegroundCalled = true;
                   mCurrentForegroundServiceType = foregroundServiceType;
-                  shouldPostNotificationAgain = false;
                 }
+              } else {
+                Trace.beginSection("notifee:startForeground");
+                try {
+                  startForeground(hashCode, notification);
+                } finally {
+                  Trace.endSection();
+                }
+                mStartForegroundCalled = true;
               }
-              if (shouldPostNotificationAgain) {
-                NotificationManagerCompat.from(ContextHolder.getApplicationContext())
-                    .notify(hashCode, notification);
+
+              if (!noneEarlyReturn) {
+                // On headless task complete
+                final MethodCallResult<Void> methodCallResult =
+                    (e, aVoid) -> {
+                      stopForegroundCompat();
+                      synchronized (sLock) {
+                        mCurrentNotificationId = null;
+                        mCurrentForegroundServiceType = -1;
+                        mCurrentNotificationBundle = null;
+                        mCurrentNotification = null;
+                        mCurrentHashCode = 0;
+                      }
+                    };
+
+                pendingEvent = new ForegroundServiceEvent(notificationModel, methodCallResult);
               }
             } else {
-              pendingEvent =
-                  new NotificationEvent(NotificationEvent.TYPE_FG_ALREADY_EXIST, notificationModel);
+              if (mCurrentNotificationId.equals(notificationModel.getId())) {
+                boolean shouldPostNotificationAgain = true;
+                // find if we need to start the service again if the type was changed
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                  int foregroundServiceType =
+                      notificationModel.getAndroid().getForegroundServiceType();
+                  if (foregroundServiceType == ServiceInfo.FOREGROUND_SERVICE_TYPE_MANIFEST) {
+                    foregroundServiceType = resolveManifestServiceType();
+                  }
+                  if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE
+                      && foregroundServiceType == ServiceInfo.FOREGROUND_SERVICE_TYPE_NONE) {
+                    Logger.e(
+                        TAG,
+                        "Resolved foreground service type is NONE on API 34+; skipping type"
+                            + " change.");
+                  } else if (foregroundServiceType != mCurrentForegroundServiceType) {
+                    Trace.beginSection("notifee:startForeground");
+                    try {
+                      startForeground(hashCode, notification, foregroundServiceType);
+                    } finally {
+                      Trace.endSection();
+                    }
+                    mStartForegroundCalled = true;
+                    mCurrentForegroundServiceType = foregroundServiceType;
+                    shouldPostNotificationAgain = false;
+                  }
+                }
+                if (shouldPostNotificationAgain) {
+                  NotificationManagerCompat.from(ContextHolder.getApplicationContext())
+                      .notify(hashCode, notification);
+                }
+              } else {
+                pendingEvent =
+                    new NotificationEvent(
+                        NotificationEvent.TYPE_FG_ALREADY_EXIST, notificationModel);
+              }
             }
           }
-        }
 
-        if (pendingEvent != null) {
-          EventBus.post(pendingEvent);
+          // Handle NONE early return outside the lock — the helper performs Binder IPC
+          // (PackageManager query + startForeground) that must not hold sLock.
+          if (noneEarlyReturn) {
+            ensureStartForegroundContractSatisfied();
+            return START_NOT_STICKY;
+          }
+
+          if (pendingEvent != null) {
+            EventBus.post(pendingEvent);
+          }
         }
       }
-    }
 
-    return START_NOT_STICKY;
+      return START_NOT_STICKY;
+    } finally {
+      Trace.endSection();
+    }
   }
 
   @Nullable
@@ -305,6 +370,26 @@ public class ForegroundService extends Service {
         : ServiceInfo.FOREGROUND_SERVICE_TYPE_MANIFEST;
   }
 
+  /**
+   * Ensures the defensive notification channel exists. Required for the placeholder notification
+   * used on the STOP path when startForeground() was never called on this instance.
+   */
+  private void ensureDefensiveChannel() {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      NotificationManager nm = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
+      if (nm != null && nm.getNotificationChannel(DEFENSIVE_CHANNEL_ID) == null) {
+        NotificationChannel channel =
+            new NotificationChannel(
+                DEFENSIVE_CHANNEL_ID, "Foreground Service", NotificationManager.IMPORTANCE_MIN);
+        channel.setShowBadge(false);
+        channel.enableLights(false);
+        channel.enableVibration(false);
+        channel.setSound(null, null);
+        nm.createNotificationChannel(channel);
+      }
+    }
+  }
+
   @SuppressWarnings("deprecation")
   private void stopForegroundCompat() {
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
@@ -314,6 +399,110 @@ public class ForegroundService extends Service {
     }
   }
 
+  /**
+   * Queries the PackageManager for the {@code foregroundServiceType} attribute declared on this
+   * service's {@code <service>} element in AndroidManifest.xml.
+   *
+   * <p>This is intentionally separate from {@link #resolveManifestServiceType()} (which resolves
+   * the effective type for the normal startForeground path). That method is static, uses {@link
+   * ContextHolder#getApplicationContext()} (which may be null during early recreation), and has
+   * different return semantics — it maps missing types to {@code FOREGROUND_SERVICE_TYPE_MANIFEST}
+   * on API 29-33 and to {@code FOREGROUND_SERVICE_TYPE_NONE} on API 34+. This method is an instance
+   * method that uses {@code this} as context (always valid inside a running Service) and returns
+   * the raw declared value without any API-level mapping, which is what the proactive manifest
+   * check in {@link #ensureStartForegroundContractSatisfied()} needs.
+   *
+   * @return the raw {@code foregroundServiceType} bitmask from the manifest, or 0 if the service is
+   *     not declared or has no explicit type
+   */
+  private int getDeclaredForegroundServiceType() {
+    try {
+      ComponentName component = new ComponentName(this, ForegroundService.class);
+      ServiceInfo info =
+          getPackageManager().getServiceInfo(component, PackageManager.GET_META_DATA);
+      return info.getForegroundServiceType();
+    } catch (PackageManager.NameNotFoundException e) {
+      return 0;
+    }
+  }
+
+  /**
+   * Ensures Android's 5-second {@code startForeground()} contract is satisfied before an early
+   * return from {@link #onStartCommand(Intent, int, int)}.
+   *
+   * <p>This method is idempotent: if {@link #mStartForegroundCalled} is already {@code true} (i.e.,
+   * this service instance has previously called {@code startForeground()} successfully), this
+   * method returns immediately without side effects.
+   *
+   * <p>On API 34+ (Android 14), this method performs a proactive manifest check via {@link
+   * #getDeclaredForegroundServiceType()} before attempting the defensive {@code startForeground()}
+   * call. If no {@code foregroundServiceType} is declared in the manifest, the method throws a
+   * {@link RuntimeException} with a clear error message and documentation URL instead of proceeding
+   * to a call that would fail with a cryptic {@code SecurityException}.
+   *
+   * <p>On API levels below 34, the manifest check is skipped and the defensive {@code
+   * startForeground()} is called directly, as no {@code foregroundServiceType} declaration is
+   * required.
+   *
+   * @throws RuntimeException if the manifest is missing required {@code foregroundServiceType}
+   *     declarations on API 34+, or if the defensive {@code startForeground()} call fails for any
+   *     other reason. In both cases, the exception terminates the process with a crash report that
+   *     is more actionable than the ANR that would otherwise occur.
+   */
+  @SuppressLint({"ForegroundServiceType", "MissingPermission"})
+  private void ensureStartForegroundContractSatisfied() {
+    if (mStartForegroundCalled) {
+      return;
+    }
+
+    // Proactive manifest check on API 34+: fail fast with actionable message.
+    // Also caches the declared type for use in the 3-param startForeground() call below.
+    int declaredTypes = 0;
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+      declaredTypes = getDeclaredForegroundServiceType();
+      if (declaredTypes == 0) {
+        String msg =
+            "react-native-notify-kit: ForegroundService cannot start — "
+                + "no foregroundServiceType declared in AndroidManifest.xml on API 34+. "
+                + "See https://github.com/marcocrupi/react-native-notify-kit"
+                + "#foreground-service-setup-android-14";
+        Logger.e(TAG, msg);
+        // Intentional crash: a RuntimeException here terminates the process with a clear,
+        // actionable crash report within milliseconds — well inside the 5-second ANR budget.
+        // The alternative (catching and calling stopSelf()) leaves Android's startForeground()
+        // contract unsatisfied, which produces a ForegroundServiceDidNotStartInTimeException
+        // ANR with a framework-only stack trace that gives no indication of the root cause.
+        // Do NOT suppress this throw without also providing an alternative mechanism to satisfy
+        // the startForeground() contract or terminate the process before the ANR fires.
+        throw new RuntimeException(msg);
+      }
+    }
+
+    try {
+      ensureDefensiveChannel();
+      Notification placeholder =
+          new NotificationCompat.Builder(this, DEFENSIVE_CHANNEL_ID)
+              .setSmallIcon(android.R.drawable.ic_dialog_info)
+              .build();
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+        // On API 34+, pass the manifest-declared type explicitly rather than relying on
+        // the 2-param startForeground() to resolve type 0 → manifest type. This avoids
+        // ambiguity about implicit type resolution behavior across OEM variants.
+        startForeground(DEFENSIVE_NOTIFICATION_ID, placeholder, declaredTypes);
+      } else {
+        startForeground(DEFENSIVE_NOTIFICATION_ID, placeholder);
+      }
+      mStartForegroundCalled = true;
+      stopForegroundCompat();
+    } catch (Exception e) {
+      String msg =
+          "react-native-notify-kit: defensive startForeground() failed. "
+              + "This indicates an inconsistent service state and the process cannot recover.";
+      Logger.e(TAG, msg, e);
+      throw new RuntimeException(msg, e);
+    }
+  }
+
   private void handleTimeout(int startId, int fgsType) {
     Logger.e(
         TAG,

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

@@ -20,12 +20,17 @@ package app.notifee.core;
 import android.content.ContentProvider;
 import android.content.ContentValues;
 import android.content.Context;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageManager;
 import android.content.pm.ProviderInfo;
 import android.database.Cursor;
 import android.net.Uri;
+import android.os.Trace;
 import androidx.annotation.CallSuper;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
 
 @KeepForSdk
 public class InitProvider extends ContentProvider {
@@ -42,21 +47,59 @@ public class InitProvider extends ContentProvider {
     super.attachInfo(context, info);
   }
 
+  private static final String TAG = "InitProvider";
+
   @KeepForSdk
   @CallSuper
   @Override
   public boolean onCreate() {
-    if (ContextHolder.getApplicationContext() == null) {
-      Context context = getContext();
-      if (context != null && context.getApplicationContext() != null) {
-        context = context.getApplicationContext();
+    Trace.beginSection("notifee:InitProvider.onCreate");
+    try {
+      if (ContextHolder.getApplicationContext() == null) {
+        Context context = getContext();
+        if (context != null && context.getApplicationContext() != null) {
+          context = context.getApplicationContext();
+        }
+        ContextHolder.setApplicationContext(context);
+      }
+
+      Context appContext = ContextHolder.getApplicationContext();
+      if (appContext != null && isWarmupEnabled(appContext)) {
+        dispatchWarmup(appContext);
       }
-      ContextHolder.setApplicationContext(context);
+    } finally {
+      Trace.endSection();
     }
 
     return false;
   }
 
+  private static boolean isWarmupEnabled(Context context) {
+    try {
+      ApplicationInfo ai =
+          context
+              .getPackageManager()
+              .getApplicationInfo(context.getPackageName(), PackageManager.GET_META_DATA);
+      return ai.metaData == null || ai.metaData.getBoolean("notifee_init_warmup_enabled", true);
+    } catch (PackageManager.NameNotFoundException e) {
+      return true;
+    }
+  }
+
+  private static void dispatchWarmup(final Context context) {
+    ExecutorService executor =
+        Executors.newSingleThreadExecutor(
+            r -> {
+              Thread t = new Thread(r, "notifee-init-warmup");
+              t.setDaemon(true);
+              t.setPriority(Thread.MIN_PRIORITY);
+              return t;
+            });
+
+    executor.submit(() -> WarmupHelper.runWarmup(context));
+    executor.shutdown();
+  }
+
   @Nullable
   @Override
   public Cursor query(

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

@@ -48,6 +48,11 @@ public class Logger {
     Log.w(TAG, tagAndMessage(tag, message));
   }
 
+  @KeepForSdk
+  public static void w(@NonNull String tag, String message, Throwable throwable) {
+    Log.w(TAG, tagAndMessage(tag, message), throwable);
+  }
+
   @KeepForSdk
   public static void e(@NonNull String tag, String message, Exception e) {
     Log.e(TAG, tagAndMessage(tag, message), e);