react-native-notify-kit 10.4.4 → 10.4.5

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/version.d.ts

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

package/dist/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-notify-kit",
-  "version": "10.4.4",
+  "version": "10.4.5",
   "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/version.ts

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