react-native-notify-kit 10.4.4 → 10.4.6

package/README.md

@@ -499,7 +499,7 @@ This fork fixes the following bugs that were never resolved in the original Noti
 
 <!-- markdownlint-disable-line MD028 -->
 
-> **Note for apps requiring guaranteed exact alarms (alarm clocks, timers, calendars):**
+> **Note for policy-eligible apps requiring exact alarm APIs (alarm clocks, timers, calendars):**
 > Add `<uses-permission android:name="android.permission.USE_EXACT_ALARM" />` to your app's
 > `AndroidManifest.xml`. This permission is auto-granted and not revocable, but Google Play
 > restricts its use to apps whose core function requires exact timing.
@@ -659,6 +659,13 @@ The original Notifee used WorkManager by default, which is battery-friendly but
 for time-sensitive notifications — Android may defer or drop WorkManager tasks based on
 battery optimization, Doze mode, and OEM power management.
 
+This path also handles normal reboot recovery. Android clears `AlarmManager` registrations
+during reboot, but NotifyKit persists local trigger notifications and re-arms them after boot.
+Future one-shot `TriggerType.TIMESTAMP` triggers are supported by this recovery path; a trigger
+does not need to be recurring or daily only to survive reboot, and push notifications are not
+required for local scheduled trigger recovery. If exact-alarm access is missing, NotifyKit falls
+back to an inexact alarm so the trigger is retained, but exact fire timing is not guaranteed.
+
 If you need battery-friendly scheduling where exact timing is not critical (e.g., daily digest
 notifications), you can opt out:
 
@@ -719,12 +726,14 @@ await notifee.createTriggerNotification(
 );
 ```
 
-**Required permissions on Android 12+.** `SET_EXACT`, `SET_EXACT_AND_ALLOW_WHILE_IDLE`, and
-`SET_ALARM_CLOCK` all require the `SCHEDULE_EXACT_ALARM` or `USE_EXACT_ALARM` permission.
-If the permission is not granted, Notifee falls back to `setAndAllowWhileIdle` (inexact)
-instead of crashing — see the `SecurityException` handling in `NotifeeAlarmManager`.
-For use cases that must be exact on first install, declare `USE_EXACT_ALARM` in your manifest
-and consider prompting the user with `openAlarmPermissionSettings()`.
+**Exact-alarm permission on Android 12+.** `SET_EXACT`, `SET_EXACT_AND_ALLOW_WHILE_IDLE`,
+and `SET_ALARM_CLOCK` all require exact-alarm access through `SCHEDULE_EXACT_ALARM` or
+`USE_EXACT_ALARM`. This affects exact fire timing, not trigger persistence. If permission is
+not granted, Notifee falls back to `setAndAllowWhileIdle` (inexact) instead of crashing or
+dropping the trigger. Apps that require exact timing should check
+`getNotificationSettings().android.alarm`, explain the permission, and guide users with
+`openAlarmPermissionSettings()`. `SET_ALARM_CLOCK` can be considered for alarm-clock or
+timer-like use cases within Android and Google Play policy constraints.
 
 ### Timers: foreground service or `SET_ALARM_CLOCK`?
 
@@ -810,6 +819,33 @@ Default is `true` (backward compatible — Notifee handles everything, same as o
 
 ### Troubleshooting
 
+#### Scheduled Android trigger notifications do not fire after reboot
+
+Android removes `AlarmManager` registrations during reboot. NotifyKit persists local trigger
+notifications and re-arms them through `app.notifee.core.RebootBroadcastReceiver` after a
+normal reboot, with a cold-start `BOOT_COUNT` recovery path for devices that delay or suppress
+`BOOT_COMPLETED`. If triggers do not return after reboot, check the generated app rather than
+only the source manifest:
+
+- Verify the final merged manifest contains `android.permission.RECEIVE_BOOT_COMPLETED`,
+  `android.permission.SCHEDULE_EXACT_ALARM`, `app.notifee.core.RebootBroadcastReceiver` with
+  `android.intent.action.BOOT_COMPLETED`, `app.notifee.core.NotificationAlarmReceiver`, and
+  `io.invertase.notifee.NotifeeInitProvider`.
+- For Expo CNG/prebuild apps, these entries normally arrive from the NotifyKit library manifest
+  through manifest merge. A custom boot-receiver config plugin is usually unnecessary and can
+  break recovery if it replaces the receiver declaration or intent filters.
+- Use package-specific logcat output. Do not rely only on `adb logcat -s NOTIFEE`; reboot
+  recovery logs use native tags such as `RebootReceiver`, `NotifeeAlarmManager`, `InitProvider`,
+  and `AlarmPermissionReceiver`, while Android broadcast logs include your real application ID.
+- Compare `adb shell dumpsys alarm` before and after reboot, filtered by your real package name,
+  to confirm the pending alarm disappears during reboot and is re-armed afterward.
+- Check exact-alarm permission if timing is late. Without permission, NotifyKit falls back to an
+  inexact alarm: the trigger is retained, but exact fire timing is not guaranteed.
+- Check OEM autostart and background restrictions, especially on Xiaomi/Redmi, Oppo/Realme,
+  Huawei/Honor, Vivo/iQOO, and Samsung devices.
+- Validate with 1-5 future one-shot `TriggerType.TIMESTAMP` triggers before scaling up to large
+  batches such as 50 active triggers.
+
 #### Small icon not showing in Android release builds (falls back to launcher icon)
 
 From 10.1.0, when the resource ID for `android.smallIcon` cannot be resolved at runtime, the library logs a warning and falls back to your app's launcher icon instead of failing the notification display. If you see your launcher icon in a notification where you expected a custom small icon, filter logcat for the `NOTIFEE` tag to find the resolution failure.

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

@@ -451,23 +451,27 @@ class NotificationManager {
                     PendingIntent pendingIntent = null;
                     int targetSdkVersion =
                         ContextHolder.getApplicationContext().getApplicationInfo().targetSdkVersion;
+                    NotificationAndroidPressActionModel pressAction = actionBundle.getPressAction();
+                    boolean shouldCreateLaunchActivityIntent =
+                        NotificationPendingIntent.shouldCreateLaunchActivityIntent(pressAction);
                     if (targetSdkVersion >= Build.VERSION_CODES.S
-                        && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+                        && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S
+                        && shouldCreateLaunchActivityIntent) {
                       pendingIntent =
                           NotificationPendingIntent.createIntent(
                               notificationModel.getHashCode(),
-                              actionBundle.getPressAction().toBundle(),
+                              pressAction.toBundle(),
                               TYPE_ACTION_PRESS,
                               new String[] {"notification", "pressAction"},
                               notificationModel.toBundle(),
-                              actionBundle.getPressAction().toBundle());
+                              pressAction.toBundle());
                     } else {
                       pendingIntent =
                           ReceiverService.createIntent(
                               ACTION_PRESS_INTENT,
                               new String[] {"notification", "pressAction"},
                               notificationModel.toBundle(),
-                              actionBundle.getPressAction().toBundle());
+                              pressAction.toBundle());
                     }
 
                     String icon = actionBundle.getIcon();

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

@@ -98,9 +98,21 @@ class HeadlessTask {
 
         if (!mIsReactContextInitialized.get()) {
             createReactContextAndScheduleTask(context)
-        } else {
-            invokeStartTask(getReactContext(context)!!, taskConfig)
+            return
+        }
+
+        val reactContext = getReactContext(context)
+        if (reactContext == null) {
+            Log.w(HEADLESS_TASK_NAME, "ReactContext is stale, reinitializing ReactHost")
+            mIsReactContextInitialized.set(false)
+            mWillDrainTaskQueue.set(false)
+            mIsInitializingReactContext.set(false)
+            mIsHeadlessJsTaskListenerRegistered.set(false)
+            createReactContextAndScheduleTask(context, reactContext)
+            return
         }
+
+        invokeStartTask(reactContext, taskConfig)
     }
 
     @Synchronized
@@ -139,11 +151,13 @@ class HeadlessTask {
         }
     }
 
-    private fun createReactContextAndScheduleTask(context: Context) {
-        val reactContext = getReactContext(context)
+    private fun createReactContextAndScheduleTask(
+        context: Context,
+        reactContext: ReactContext? = getReactContext(context),
+    ) {
         if (reactContext != null && !mIsInitializingReactContext.get()) {
             mIsReactContextInitialized.set(true)
-            drainTaskQueue(reactContext)
+            drainTaskQueue(context, reactContext)
             return
         }
         if (mIsInitializingReactContext.compareAndSet(false, true)) {
@@ -152,7 +166,7 @@ class HeadlessTask {
             val callback = object : ReactInstanceEventListener {
                 override fun onReactContextInitialized(reactCtx: ReactContext) {
                     mIsReactContextInitialized.set(true)
-                    drainTaskQueue(reactCtx)
+                    drainTaskQueue(context, reactCtx)
                     try {
                         val removeMethod = reactHost!!.javaClass.getMethod(
                             "removeReactInstanceEventListener",
@@ -178,10 +192,12 @@ class HeadlessTask {
         }
     }
 
-    private fun drainTaskQueue(reactContext: ReactContext) {
+    private fun drainTaskQueue(context: Context, reactContext: ReactContext) {
         if (mWillDrainTaskQueue.compareAndSet(false, true)) {
             Handler(Looper.getMainLooper()).postDelayed(
                 {
+                    if (getReactContext(context) !== reactContext) return@postDelayed
+
                     synchronized(mTaskQueue) {
                         for (taskConfig in mTaskQueue) {
                             invokeStartTask(reactContext, taskConfig)

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

@@ -0,0 +1,305 @@
+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 static app.notifee.core.NotificationPendingIntent.EVENT_TYPE_INTENT_KEY;
+import static app.notifee.core.event.NotificationEvent.TYPE_ACTION_PRESS;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import android.Manifest;
+import android.app.Activity;
+import android.app.Notification;
+import android.app.NotificationChannel;
+import android.app.PendingIntent;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.ActivityInfo;
+import android.content.pm.ResolveInfo;
+import android.os.Build;
+import android.os.Bundle;
+import app.notifee.core.event.MainComponentEvent;
+import app.notifee.core.model.NotificationModel;
+import com.google.common.util.concurrent.ListenableFuture;
+import java.util.ArrayList;
+import java.util.concurrent.TimeUnit;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.RuntimeEnvironment;
+import org.robolectric.Shadows;
+import org.robolectric.annotation.Config;
+import org.robolectric.shadows.ShadowNotificationManager;
+import org.robolectric.shadows.ShadowPackageManager;
+import org.robolectric.shadows.ShadowPendingIntent;
+
+@RunWith(RobolectricTestRunner.class)
+@Config(sdk = 34)
+public class NotificationManagerActionRoutingTest {
+  private static final String CHANNEL_ID = "action-routing-test-channel";
+
+  private Context context;
+
+  @Before
+  public void setUp() {
+    context = RuntimeEnvironment.getApplication();
+    ContextHolder.setApplicationContext(context);
+    setTargetSdk(Build.VERSION_CODES.S);
+    ShadowPendingIntent.reset();
+    EventBus.removeStickEvent(MainComponentEvent.class);
+
+    Shadows.shadowOf(RuntimeEnvironment.getApplication())
+        .grantPermissions(Manifest.permission.POST_NOTIFICATIONS);
+    registerDefaultLaunchActivity();
+    createChannel();
+
+    android.app.NotificationManager notificationManager =
+        (android.app.NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
+    notificationManager.cancelAll();
+  }
+
+  @After
+  public void tearDown() {
+    EventBus.removeStickEvent(MainComponentEvent.class);
+    ShadowPendingIntent.reset();
+  }
+
+  @Test
+  public void displayNotification_android12PlusNoLaunchAction_routesToReceiverService()
+      throws Exception {
+    ShadowPendingIntent shadowPendingIntent =
+        actionPendingIntent(
+            displayNotification(
+                buildNotificationModel(
+                    "android12-no-launch", buildPressAction("decline", null, null))));
+
+    assertReceiverServiceActionIntent(shadowPendingIntent, "decline", null, null);
+  }
+
+  @Test
+  public void displayNotification_android12PlusLaunchActivityAction_routesToLaunchActivity()
+      throws Exception {
+    ShadowPendingIntent shadowPendingIntent =
+        actionPendingIntent(
+            displayNotification(
+                buildNotificationModel(
+                    "android12-launch-activity",
+                    buildPressAction("answer", ExplicitLaunchActivity.class.getName(), null))));
+
+    assertLaunchActivityActionIntent(
+        shadowPendingIntent,
+        ExplicitLaunchActivity.class,
+        "answer",
+        ExplicitLaunchActivity.class.getName(),
+        null);
+  }
+
+  @Test
+  public void displayNotification_android12PlusMainComponentAction_routesToLaunchActivity()
+      throws Exception {
+    ShadowPendingIntent shadowPendingIntent =
+        actionPendingIntent(
+            displayNotification(
+                buildNotificationModel(
+                    "android12-main-component",
+                    buildPressAction("open-main", null, "CustomMainComponent"))));
+
+    assertLaunchActivityActionIntent(
+        shadowPendingIntent, DefaultLaunchActivity.class, "open-main", null, "CustomMainComponent");
+  }
+
+  @Test
+  public void displayNotification_android12PlusDefaultActionId_routesToLaunchActivity()
+      throws Exception {
+    ShadowPendingIntent shadowPendingIntent =
+        actionPendingIntent(
+            displayNotification(
+                buildNotificationModel(
+                    "android12-default-action", buildPressAction("default", null, null))));
+
+    assertLaunchActivityActionIntent(
+        shadowPendingIntent, DefaultLaunchActivity.class, "default", null, null);
+  }
+
+  @Test
+  @Config(sdk = 30)
+  public void displayNotification_preAndroid12LaunchActivityAction_keepsReceiverServiceRoute()
+      throws Exception {
+    setTargetSdk(Build.VERSION_CODES.S);
+
+    ShadowPendingIntent shadowPendingIntent =
+        actionPendingIntent(
+            displayNotification(
+                buildNotificationModel(
+                    "pre-android12-launch-activity",
+                    buildPressAction("answer", ExplicitLaunchActivity.class.getName(), null))));
+
+    assertReceiverServiceActionIntent(
+        shadowPendingIntent, "answer", ExplicitLaunchActivity.class.getName(), null);
+  }
+
+  @Test
+  public void displayNotification_targetBelow31LaunchActivityAction_keepsReceiverServiceRoute()
+      throws Exception {
+    setTargetSdk(Build.VERSION_CODES.R);
+
+    ShadowPendingIntent shadowPendingIntent =
+        actionPendingIntent(
+            displayNotification(
+                buildNotificationModel(
+                    "target-below31-launch-activity",
+                    buildPressAction("answer", ExplicitLaunchActivity.class.getName(), null))));
+
+    assertReceiverServiceActionIntent(
+        shadowPendingIntent, "answer", ExplicitLaunchActivity.class.getName(), null);
+  }
+
+  private Notification displayNotification(NotificationModel notificationModel) throws Exception {
+    ListenableFuture<Void> future =
+        NotificationManager.displayNotification(notificationModel, null);
+    future.get(5, TimeUnit.SECONDS);
+
+    android.app.NotificationManager notificationManager =
+        (android.app.NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
+    ShadowNotificationManager shadowNotificationManager = Shadows.shadowOf(notificationManager);
+    Notification notification =
+        shadowNotificationManager.getNotification(notificationModel.getHashCode());
+    assertNotNull("notification must be posted", notification);
+    return notification;
+  }
+
+  private static ShadowPendingIntent actionPendingIntent(Notification notification) {
+    assertNotNull("action array must be present", notification.actions);
+    assertEquals("one action must be built", 1, notification.actions.length);
+
+    PendingIntent pendingIntent = notification.actions[0].actionIntent;
+    assertNotNull("action PendingIntent must be present", pendingIntent);
+    return Shadows.shadowOf(pendingIntent);
+  }
+
+  private static void assertReceiverServiceActionIntent(
+      ShadowPendingIntent shadowPendingIntent,
+      String id,
+      String launchActivity,
+      String mainComponent) {
+    assertTrue("action PendingIntent must target ReceiverService", shadowPendingIntent.isService());
+
+    Intent intent = shadowPendingIntent.getSavedIntent();
+    assertNotNull("service intent must be saved", intent);
+    assertEquals(ReceiverService.ACTION_PRESS_INTENT, intent.getAction());
+    assertEquals(ReceiverService.class.getName(), intent.getComponent().getClassName());
+    assertPressAction(intent.getBundleExtra("pressAction"), id, launchActivity, mainComponent);
+  }
+
+  private static void assertLaunchActivityActionIntent(
+      ShadowPendingIntent shadowPendingIntent,
+      Class<? extends Activity> launchActivityClass,
+      String id,
+      String launchActivity,
+      String mainComponent) {
+    assertTrue(
+        "action PendingIntent must use the launch-activity path", shadowPendingIntent.isActivity());
+
+    Intent[] intents = shadowPendingIntent.getSavedIntents();
+    assertNotNull("activity intent stack must be saved", intents);
+    assertEquals("launch path must include app launch and receiver activity", 2, intents.length);
+    assertEquals(launchActivityClass.getName(), intents[0].getComponent().getClassName());
+    assertEquals(
+        NotificationReceiverActivity.class.getName(), intents[1].getComponent().getClassName());
+    assertEquals(TYPE_ACTION_PRESS, intents[1].getIntExtra(EVENT_TYPE_INTENT_KEY, -1));
+    assertPressAction(intents[1].getBundleExtra("pressAction"), id, launchActivity, mainComponent);
+  }
+
+  private static void assertPressAction(
+      Bundle pressAction, String id, String launchActivity, String mainComponent) {
+    assertNotNull("pressAction extras must be present", pressAction);
+    assertEquals(id, pressAction.getString("id"));
+    assertEquals(launchActivity, pressAction.getString("launchActivity"));
+    assertEquals(mainComponent, pressAction.getString("mainComponent"));
+  }
+
+  private void registerDefaultLaunchActivity() {
+    Intent launcherIntent = new Intent(Intent.ACTION_MAIN);
+    launcherIntent.addCategory(Intent.CATEGORY_LAUNCHER);
+    launcherIntent.setPackage(context.getPackageName());
+
+    ResolveInfo resolveInfo = new ResolveInfo();
+    resolveInfo.activityInfo = new ActivityInfo();
+    resolveInfo.activityInfo.packageName = context.getPackageName();
+    resolveInfo.activityInfo.name = DefaultLaunchActivity.class.getName();
+
+    ShadowPackageManager shadowPackageManager = Shadows.shadowOf(context.getPackageManager());
+    shadowPackageManager.addActivityIfNotPresent(
+        new ComponentName(context.getPackageName(), DefaultLaunchActivity.class.getName()));
+    shadowPackageManager.addResolveInfoForIntent(launcherIntent, resolveInfo);
+  }
+
+  private void createChannel() {
+    android.app.NotificationManager notificationManager =
+        (android.app.NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
+    if (notificationManager.getNotificationChannel(CHANNEL_ID) == null) {
+      NotificationChannel channel =
+          new NotificationChannel(
+              CHANNEL_ID, "Action routing test", android.app.NotificationManager.IMPORTANCE_LOW);
+      notificationManager.createNotificationChannel(channel);
+    }
+  }
+
+  private static void setTargetSdk(int targetSdk) {
+    RuntimeEnvironment.getApplication().getApplicationInfo().targetSdkVersion = targetSdk;
+  }
+
+  private static NotificationModel buildNotificationModel(String id, Bundle pressAction) {
+    Bundle notificationBundle = new Bundle();
+    notificationBundle.putString("id", id);
+    notificationBundle.putString("title", "Action routing " + id);
+    notificationBundle.putString("body", "Body " + id);
+
+    Bundle androidBundle = new Bundle();
+    androidBundle.putString("channelId", CHANNEL_ID);
+
+    Bundle action = new Bundle();
+    action.putString("title", "Action " + pressAction.getString("id"));
+    action.putBundle("pressAction", pressAction);
+    ArrayList<Bundle> actions = new ArrayList<>();
+    actions.add(action);
+    androidBundle.putParcelableArrayList("actions", actions);
+
+    notificationBundle.putBundle("android", androidBundle);
+    return NotificationModel.fromBundle(notificationBundle);
+  }
+
+  private static Bundle buildPressAction(String id, String launchActivity, String mainComponent) {
+    Bundle pressAction = new Bundle();
+    pressAction.putString("id", id);
+    if (launchActivity != null) {
+      pressAction.putString("launchActivity", launchActivity);
+    }
+    if (mainComponent != null) {
+      pressAction.putString("mainComponent", mainComponent);
+    }
+    return pressAction;
+  }
+
+  public static class DefaultLaunchActivity extends Activity {}
+
+  public static class ExplicitLaunchActivity extends Activity {}
+}

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

@@ -8,6 +8,7 @@ import android.app.Activity;
 import android.content.Context;
 import android.content.Intent;
 import android.os.Bundle;
+import androidx.core.app.RemoteInput;
 import app.notifee.core.event.InitialNotificationEvent;
 import app.notifee.core.event.MainComponentEvent;
 import app.notifee.core.event.NotificationEvent;
@@ -73,6 +74,38 @@ public class ReceiverServiceInitialNotificationTest {
         EventBus.getStickyEvent(InitialNotificationEvent.class));
   }
 
+  @Test
+  public void onActionPressIntent_withoutLaunch_preservesRemoteInputInNotificationEvent() {
+    Intent intent =
+        buildServiceIntent(
+            buildNotificationBundle("service-action-remote-input"),
+            buildPressActionBundle("reply", null, null));
+    Bundle remoteInputResults = new Bundle();
+    remoteInputResults.putCharSequence(ReceiverService.REMOTE_INPUT_RECEIVER_KEY, "Accepted");
+    RemoteInput.addResultsToIntent(
+        new RemoteInput[] {
+          new RemoteInput.Builder(ReceiverService.REMOTE_INPUT_RECEIVER_KEY).build()
+        },
+        intent,
+        remoteInputResults);
+
+    service.onStartCommand(intent, 0, 1);
+
+    assertEquals("one NotificationEvent should be posted", 1, capture.events.size());
+    NotificationEvent event = capture.events.get(0);
+    assertEquals(NotificationEvent.TYPE_ACTION_PRESS, event.getType());
+    assertEquals("service-action-remote-input", event.getNotification().getId());
+    assertNotNull("ACTION_PRESS extras should be preserved", event.getExtras());
+    assertPressAction(event.getExtras(), "reply", null, null);
+    assertEquals(
+        "remote input result should be preserved",
+        "Accepted",
+        event.getExtras().getString("input"));
+    assertNull(
+        "no-launch remote input ACTION_PRESS should not post InitialNotificationEvent",
+        EventBus.getStickyEvent(InitialNotificationEvent.class));
+  }
+
   @Test
   public void onActionPressIntent_withLaunch_postsInitialNotificationAfterPendingIntentSend() {
     Intent intent =

package/android/src/test/java/io/invertase/notifee/HeadlessTaskReactHostTest.java

@@ -7,6 +7,7 @@ import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.ArgumentMatchers.same;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
@@ -54,11 +55,8 @@ public class HeadlessTaskReactHostTest {
     HeadlessTask headlessTask = new HeadlessTask();
     HeadlessTask.TaskConfig taskConfig =
         new HeadlessTask.TaskConfig("test-headless-task", 60000L, params, null);
-    ReactContext reactContext = mock(ReactContext.class);
     AppRegistry appRegistry = mock(AppRegistry.class);
-    when(reactContext.getLifecycleState()).thenReturn(LifecycleState.BEFORE_RESUME);
-    when(reactContext.hasActiveReactInstance()).thenReturn(true);
-    when(reactContext.getJSModule(AppRegistry.class)).thenReturn(appRegistry);
+    ReactContext reactContext = createReactContext(appRegistry);
 
     WritableMap copiedParams = taskConfig.getTaskConfig().getData();
 
@@ -73,6 +71,7 @@ public class HeadlessTaskReactHostTest {
     verify(appRegistry, never())
         .startHeadlessTask(anyInt(), any(String.class), any(WritableMap.class));
 
+    application.reactHost.currentReactContext = reactContext;
     ReactInstanceEventListener listener = application.reactHost.listeners.get(0);
     listener.onReactContextInitialized(reactContext);
 
@@ -101,6 +100,136 @@ public class HeadlessTaskReactHostTest {
         copiedParams.getInt("taskId"));
   }
 
+  @Test
+  public void
+      startTask_whenInitializedContextDisappears_reinitializesReactHostAndDrainsQueuedTasks() {
+    HeadlessTask headlessTask = new HeadlessTask();
+    AppRegistry firstAppRegistry = mock(AppRegistry.class);
+    AppRegistry secondAppRegistry = mock(AppRegistry.class);
+    ReactContext firstReactContext = createReactContext(firstAppRegistry);
+    ReactContext secondReactContext = createReactContext(secondAppRegistry);
+    HeadlessTask.TaskConfig firstTaskConfig =
+        new HeadlessTask.TaskConfig("first-headless-task", 60000L, params("first"), null);
+    HeadlessTask.TaskConfig secondTaskConfig =
+        new HeadlessTask.TaskConfig("second-headless-task", 60000L, params("second"), null);
+    HeadlessTask.TaskConfig thirdTaskConfig =
+        new HeadlessTask.TaskConfig("third-headless-task", 60000L, params("third"), null);
+    WritableMap firstCopiedParams = firstTaskConfig.getTaskConfig().getData();
+    WritableMap secondCopiedParams = secondTaskConfig.getTaskConfig().getData();
+    WritableMap thirdCopiedParams = thirdTaskConfig.getTaskConfig().getData();
+
+    headlessTask.startTask(application, firstTaskConfig);
+
+    assertEquals(1, application.reactHost.startCalls);
+    assertEquals(1, application.reactHost.listeners.size());
+
+    application.reactHost.currentReactContext = firstReactContext;
+    application.reactHost.listeners.get(0).onReactContextInitialized(firstReactContext);
+    Shadows.shadowOf(Looper.getMainLooper())
+        .idleFor(500, java.util.concurrent.TimeUnit.MILLISECONDS);
+
+    verify(firstAppRegistry)
+        .startHeadlessTask(anyInt(), eq("first-headless-task"), same(firstCopiedParams));
+
+    application.reactHost.currentReactContext = null;
+
+    headlessTask.startTask(application, secondTaskConfig);
+
+    assertEquals(
+        "ReactHost should be started again for stale ReactContext",
+        2,
+        application.reactHost.startCalls);
+    assertEquals(1, application.reactHost.listeners.size());
+    verify(secondAppRegistry, never())
+        .startHeadlessTask(anyInt(), any(String.class), any(WritableMap.class));
+
+    headlessTask.startTask(application, thirdTaskConfig);
+
+    assertEquals(
+        "ReactHost should not be started again while reinitialization is pending",
+        2,
+        application.reactHost.startCalls);
+    verify(secondAppRegistry, never())
+        .startHeadlessTask(anyInt(), any(String.class), any(WritableMap.class));
+
+    application.reactHost.currentReactContext = secondReactContext;
+    application.reactHost.listeners.get(0).onReactContextInitialized(secondReactContext);
+    Shadows.shadowOf(Looper.getMainLooper())
+        .idleFor(499, java.util.concurrent.TimeUnit.MILLISECONDS);
+    verify(secondAppRegistry, never())
+        .startHeadlessTask(anyInt(), any(String.class), any(WritableMap.class));
+
+    Shadows.shadowOf(Looper.getMainLooper()).idleFor(1, java.util.concurrent.TimeUnit.MILLISECONDS);
+
+    verify(firstAppRegistry, times(1))
+        .startHeadlessTask(anyInt(), eq("first-headless-task"), same(firstCopiedParams));
+    verify(secondAppRegistry)
+        .startHeadlessTask(anyInt(), eq("second-headless-task"), same(secondCopiedParams));
+    verify(secondAppRegistry)
+        .startHeadlessTask(anyInt(), eq("third-headless-task"), same(thirdCopiedParams));
+  }
+
+  @Test
+  public void startTask_whenContextDisappearsBeforeInitialDrain_waitsForRecoveredReactContext() {
+    HeadlessTask headlessTask = new HeadlessTask();
+    AppRegistry staleAppRegistry = mock(AppRegistry.class);
+    AppRegistry recoveredAppRegistry = mock(AppRegistry.class);
+    ReactContext staleReactContext = createReactContext(staleAppRegistry);
+    ReactContext recoveredReactContext = createReactContext(recoveredAppRegistry);
+    HeadlessTask.TaskConfig firstTaskConfig =
+        new HeadlessTask.TaskConfig("pending-first-headless-task", 60000L, params("first"), null);
+    HeadlessTask.TaskConfig secondTaskConfig =
+        new HeadlessTask.TaskConfig("pending-second-headless-task", 60000L, params("second"), null);
+    WritableMap firstCopiedParams = firstTaskConfig.getTaskConfig().getData();
+    WritableMap secondCopiedParams = secondTaskConfig.getTaskConfig().getData();
+
+    headlessTask.startTask(application, firstTaskConfig);
+    application.reactHost.currentReactContext = staleReactContext;
+    application.reactHost.listeners.get(0).onReactContextInitialized(staleReactContext);
+
+    application.reactHost.currentReactContext = null;
+    headlessTask.startTask(application, secondTaskConfig);
+
+    assertEquals(
+        "ReactHost should be restarted when the pending context disappears",
+        2,
+        application.reactHost.startCalls);
+    assertEquals(1, application.reactHost.listeners.size());
+
+    Shadows.shadowOf(Looper.getMainLooper())
+        .idleFor(500, java.util.concurrent.TimeUnit.MILLISECONDS);
+    verify(staleAppRegistry, never())
+        .startHeadlessTask(anyInt(), any(String.class), any(WritableMap.class));
+    verify(recoveredAppRegistry, never())
+        .startHeadlessTask(anyInt(), any(String.class), any(WritableMap.class));
+
+    application.reactHost.currentReactContext = recoveredReactContext;
+    application.reactHost.listeners.get(0).onReactContextInitialized(recoveredReactContext);
+    Shadows.shadowOf(Looper.getMainLooper())
+        .idleFor(500, java.util.concurrent.TimeUnit.MILLISECONDS);
+
+    verify(staleAppRegistry, never())
+        .startHeadlessTask(anyInt(), any(String.class), any(WritableMap.class));
+    verify(recoveredAppRegistry)
+        .startHeadlessTask(anyInt(), eq("pending-first-headless-task"), same(firstCopiedParams));
+    verify(recoveredAppRegistry)
+        .startHeadlessTask(anyInt(), eq("pending-second-headless-task"), same(secondCopiedParams));
+  }
+
+  private static JavaOnlyMap params(String source) {
+    JavaOnlyMap params = new JavaOnlyMap();
+    params.putString("source", source);
+    return params;
+  }
+
+  private static ReactContext createReactContext(AppRegistry appRegistry) {
+    ReactContext reactContext = mock(ReactContext.class);
+    when(reactContext.getLifecycleState()).thenReturn(LifecycleState.BEFORE_RESUME);
+    when(reactContext.hasActiveReactInstance()).thenReturn(true);
+    when(reactContext.getJSModule(AppRegistry.class)).thenReturn(appRegistry);
+    return reactContext;
+  }
+
   public static class TestApplication extends Application {
     final TestReactHost reactHost = new TestReactHost();
 
@@ -111,10 +240,11 @@ public class HeadlessTaskReactHostTest {
 
   public static class TestReactHost {
     int startCalls;
+    ReactContext currentReactContext;
     final List<ReactInstanceEventListener> listeners = new ArrayList<>();
 
     public ReactContext getCurrentReactContext() {
-      return null;
+      return currentReactContext;
     }
 
     public void addReactInstanceEventListener(ReactInstanceEventListener listener) {
@@ -131,6 +261,7 @@ public class HeadlessTaskReactHostTest {
 
     void reset() {
       startCalls = 0;
+      currentReactContext = null;
       listeners.clear();
     }
   }

package/dist/NotifeeNativeModule.d.ts

@@ -5,8 +5,9 @@ export interface NativeModuleConfig {
     nativeEvents: string[];
 }
 export default class NotifeeNativeModule {
-    private _nativeModule;
-    private _nativeEmitter;
+    private readonly _config;
+    private _nativeModule?;
+    private _nativeEmitter?;
     constructor(config: NativeModuleConfig);
     get emitter(): import("react-native/Libraries/vendor/emitter/EventEmitter").default;
     get native(): Spec;

package/dist/NotifeeNativeModule.js

@@ -4,23 +4,46 @@
 import NotifeeJSEventEmitter from './NotifeeJSEventEmitter';
 import { NativeEventEmitter, TurboModuleRegistry } from 'react-native';
 export default class NotifeeNativeModule {
+    _config;
     _nativeModule;
     _nativeEmitter;
     constructor(config) {
-        this._nativeModule = TurboModuleRegistry.getEnforcing(config.nativeModuleName);
-        // @ts-ignore - change here needs resolution https://github.com/DefinitelyTyped/DefinitelyTyped/pull/49560/files
-        this._nativeEmitter = new NativeEventEmitter(this.native);
-        for (let i = 0; i < config.nativeEvents.length; i++) {
-            const eventName = config.nativeEvents[i];
-            this._nativeEmitter.addListener(eventName, (payload) => {
-                this.emitter.emit(eventName, payload);
-            });
-        }
+        // Defer all native access out of the constructor. The default export of this package is a
+        // singleton constructed at module-evaluation time, so resolving the TurboModule here meant
+        // it ran the instant `react-native-notify-kit` was imported. On the New Architecture in
+        // bridgeless mode, importing the package early (e.g. registering `onBackgroundEvent` at the
+        // top of index.js, before the app root mounts) executes before TurboModules are installed,
+        // so `getEnforcing` throws "NotifeeApiModule could not be found" / "runtime not ready" and
+        // the module is unusable for the whole session. Resolving lazily on first `.native` access
+        // defers it until a notifee method actually runs, when the TurboModule is available.
+        this._config = config;
     }
     get emitter() {
         return NotifeeJSEventEmitter;
     }
     get native() {
+        if (!this._nativeModule || !this._nativeEmitter) {
+            const nativeModule = TurboModuleRegistry.getEnforcing(this._config.nativeModuleName);
+            // @ts-ignore - change here needs resolution https://github.com/DefinitelyTyped/DefinitelyTyped/pull/49560/files
+            const nativeEmitter = new NativeEventEmitter(nativeModule);
+            const subscriptions = [];
+            try {
+                for (let i = 0; i < this._config.nativeEvents.length; i++) {
+                    const eventName = this._config.nativeEvents[i];
+                    subscriptions.push(nativeEmitter.addListener(eventName, (payload) => {
+                        this.emitter.emit(eventName, payload);
+                    }));
+                }
+            }
+            catch (error) {
+                for (let i = 0; i < subscriptions.length; i++) {
+                    subscriptions[i].remove();
+                }
+                throw error;
+            }
+            this._nativeModule = nativeModule;
+            this._nativeEmitter = nativeEmitter;
+        }
         return this._nativeModule;
     }
 }

package/dist/NotifeeNativeModule.js.map

@@ -1 +1 @@
-{"version":3,"file":"NotifeeNativeModule.js","sourceRoot":"","sources":["../src/NotifeeNativeModule.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,qBAAqB,MAAM,yBAAyB,CAAC;AAC5D,OAAO,EAAqB,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAS1F,MAAM,CAAC,OAAO,OAAO,mBAAmB;IAC9B,aAAa,CAAO;IACpB,cAAc,CAAqB;IAE3C,YAAmB,MAA0B;QAC3C,IAAI,CAAC,aAAa,GAAG,mBAAmB,CAAC,YAAY,CAAO,MAAM,CAAC,gBAAgB,CAAC,CAAC;QAErF,gHAAgH;QAChH,IAAI,CAAC,cAAc,GAAG,IAAI,kBAAkB,CAAC,IAAI,CAAC,MAAyC,CAAC,CAAC;QAC7F,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,YAAY,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACpD,MAAM,SAAS,GAAG,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;YACzC,IAAI,CAAC,cAAc,CAAC,WAAW,CAAC,SAAS,EAAE,CAAC,OAAY,EAAE,EAAE;gBAC1D,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;YACxC,CAAC,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IAED,IAAW,OAAO;QAChB,OAAO,qBAAqB,CAAC;IAC/B,CAAC;IAED,IAAW,MAAM;QACf,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;CACF"}
+{"version":3,"file":"NotifeeNativeModule.js","sourceRoot":"","sources":["../src/NotifeeNativeModule.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,qBAAqB,MAAM,yBAAyB,CAAC;AAC5D,OAAO,EAAqB,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAS1F,MAAM,CAAC,OAAO,OAAO,mBAAmB;IACrB,OAAO,CAAqB;IACrC,aAAa,CAAQ;IACrB,cAAc,CAAsB;IAE5C,YAAmB,MAA0B;QAC3C,0FAA0F;QAC1F,2FAA2F;QAC3F,wFAAwF;QACxF,4FAA4F;QAC5F,2FAA2F;QAC3F,2FAA2F;QAC3F,2FAA2F;QAC3F,qFAAqF;QACrF,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;IACxB,CAAC;IAED,IAAW,OAAO;QAChB,OAAO,qBAAqB,CAAC;IAC/B,CAAC;IAED,IAAW,MAAM;QACf,IAAI,CAAC,IAAI,CAAC,aAAa,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC;YAChD,MAAM,YAAY,GAAG,mBAAmB,CAAC,YAAY,CAAO,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAAC,CAAC;YAE3F,gHAAgH;YAChH,MAAM,aAAa,GAAG,IAAI,kBAAkB,CAAC,YAA+C,CAAC,CAAC;YAC9F,MAAM,aAAa,GAAwB,EAAE,CAAC;YAE9C,IAAI,CAAC;gBACH,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;oBAC1D,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;oBAC/C,aAAa,CAAC,IAAI,CAChB,aAAa,CAAC,WAAW,CAAC,SAAS,EAAE,CAAC,OAAY,EAAE,EAAE;wBACpD,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;oBACxC,CAAC,CAAC,CACH,CAAC;gBACJ,CAAC;YACH,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,aAAa,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;oBAC9C,aAAa,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;gBAC5B,CAAC;gBACD,MAAM,KAAK,CAAC;YACd,CAAC;YAED,IAAI,CAAC,aAAa,GAAG,YAAY,CAAC;YAClC,IAAI,CAAC,cAAc,GAAG,aAAa,CAAC;QACtC,CAAC;QACD,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;CACF"}

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "10.4.4";
+export declare const version = "10.4.6";

package/dist/version.js

@@ -1,3 +1,3 @@
 // Generated by genversion.
-export const version = '10.4.4';
+export const version = '10.4.6';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-notify-kit",
-  "version": "10.4.4",
+  "version": "10.4.6",
   "author": "Marco Crupi",
   "description": "Maintained Notifee-compatible React Native notifications library for Android, iOS, FCM Mode, rich notifications, foreground services, and Expo CNG development builds.",
   "main": "dist/index.js",

package/src/NotifeeNativeModule.ts

@@ -13,20 +13,20 @@ export interface NativeModuleConfig {
 }
 
 export default class NotifeeNativeModule {
-  private _nativeModule: Spec;
-  private _nativeEmitter: NativeEventEmitter;
+  private readonly _config: NativeModuleConfig;
+  private _nativeModule?: Spec;
+  private _nativeEmitter?: NativeEventEmitter;
 
   public constructor(config: NativeModuleConfig) {
-    this._nativeModule = TurboModuleRegistry.getEnforcing<Spec>(config.nativeModuleName);
-
-    // @ts-ignore - change here needs resolution https://github.com/DefinitelyTyped/DefinitelyTyped/pull/49560/files
-    this._nativeEmitter = new NativeEventEmitter(this.native as EventSubscription['subscriber']);
-    for (let i = 0; i < config.nativeEvents.length; i++) {
-      const eventName = config.nativeEvents[i];
-      this._nativeEmitter.addListener(eventName, (payload: any) => {
-        this.emitter.emit(eventName, payload);
-      });
-    }
+    // Defer all native access out of the constructor. The default export of this package is a
+    // singleton constructed at module-evaluation time, so resolving the TurboModule here meant
+    // it ran the instant `react-native-notify-kit` was imported. On the New Architecture in
+    // bridgeless mode, importing the package early (e.g. registering `onBackgroundEvent` at the
+    // top of index.js, before the app root mounts) executes before TurboModules are installed,
+    // so `getEnforcing` throws "NotifeeApiModule could not be found" / "runtime not ready" and
+    // the module is unusable for the whole session. Resolving lazily on first `.native` access
+    // defers it until a notifee method actually runs, when the TurboModule is available.
+    this._config = config;
   }
 
   public get emitter() {
@@ -34,6 +34,32 @@ export default class NotifeeNativeModule {
   }
 
   public get native(): Spec {
+    if (!this._nativeModule || !this._nativeEmitter) {
+      const nativeModule = TurboModuleRegistry.getEnforcing<Spec>(this._config.nativeModuleName);
+
+      // @ts-ignore - change here needs resolution https://github.com/DefinitelyTyped/DefinitelyTyped/pull/49560/files
+      const nativeEmitter = new NativeEventEmitter(nativeModule as EventSubscription['subscriber']);
+      const subscriptions: EventSubscription[] = [];
+
+      try {
+        for (let i = 0; i < this._config.nativeEvents.length; i++) {
+          const eventName = this._config.nativeEvents[i];
+          subscriptions.push(
+            nativeEmitter.addListener(eventName, (payload: any) => {
+              this.emitter.emit(eventName, payload);
+            }),
+          );
+        }
+      } catch (error) {
+        for (let i = 0; i < subscriptions.length; i++) {
+          subscriptions[i].remove();
+        }
+        throw error;
+      }
+
+      this._nativeModule = nativeModule;
+      this._nativeEmitter = nativeEmitter;
+    }
     return this._nativeModule;
   }
 }

package/src/version.ts

@@ -1,2 +1,2 @@
 // Generated by genversion.
-export const version = '10.4.4';
+export const version = '10.4.6';