react-native-notify-kit 10.7.1 → 10.7.2

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

@@ -63,6 +63,8 @@ public class ForegroundService extends Service {
    */
   private volatile boolean mStartForegroundCalled = false;
 
+  // While active, mCurrent* tracks the latest state submitted by a platform call that returned
+  // normally. Android does not acknowledge that the notification was displayed.
   public static String mCurrentNotificationId = null;
 
   public static int mCurrentForegroundServiceType = -1;
@@ -72,12 +74,11 @@ public class ForegroundService extends Service {
   private static int mCurrentHashCode = 0;
 
   /**
-   * Re-posts the foreground service notification if the given notification ID matches the active
-   * foreground service. On Android 14+, users can dismiss ongoing foreground service notifications
-   * for most service types; this method restores the notification so the user remains aware of the
-   * running service.
+   * Submits the latest foreground service notification again if the given notification ID matches
+   * the active foreground service. On Android 14+, users can dismiss ongoing foreground service
+   * notifications for most service types.
    *
-   * @return true if the notification was re-posted, false otherwise
+   * @return true if a re-post was submitted without a synchronous exception, false otherwise
    */
   @SuppressLint("MissingPermission")
   static boolean repostIfActive(String notificationId) {
@@ -87,7 +88,7 @@ public class ForegroundService extends Service {
           || mCurrentNotification == null) {
         return false;
       }
-      Logger.w(TAG, "Re-posting foreground service notification dismissed by user");
+      Logger.w(TAG, "Submitting dismissed foreground service notification for re-post");
       NotificationManagerCompat.from(ContextHolder.getApplicationContext())
           .notify(mCurrentHashCode, mCurrentNotification);
       return true;
@@ -193,17 +194,13 @@ public class ForegroundService extends Service {
 
         if (notification != null && bundle != null) {
           NotificationModel notificationModel = NotificationModel.fromBundle(bundle);
+          String notificationId = notificationModel.getId();
 
           Object pendingEvent = null;
           boolean noneEarlyReturn = false;
 
           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();
@@ -216,12 +213,6 @@ public class ForegroundService extends Service {
                       TAG,
                       "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;
@@ -246,6 +237,10 @@ public class ForegroundService extends Service {
               }
 
               if (!noneEarlyReturn) {
+                mCurrentNotificationId = notificationId;
+                mCurrentNotificationBundle = bundle;
+                mCurrentNotification = notification;
+                mCurrentHashCode = hashCode;
                 // On headless task complete
                 final MethodCallResult<Void> methodCallResult =
                     (e, aVoid) -> {
@@ -262,37 +257,50 @@ public class ForegroundService extends Service {
                 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 (mCurrentNotificationId.equals(notificationId)) {
+                // Before API 31, updating the service's registered notification requires
+                // startForeground(). API 31+ processes a same-ID notify() against the foreground
+                // service record. Keep that path for an unchanged type: repeating
+                // startForeground() can extend a shortService timeout on API 34+.
+                boolean shouldStartForeground = Build.VERSION.SDK_INT < Build.VERSION_CODES.S;
+                int foregroundServiceType = mCurrentForegroundServiceType;
                 if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-                  int foregroundServiceType =
-                      notificationModel.getAndroid().getForegroundServiceType();
-                  if (foregroundServiceType == ServiceInfo.FOREGROUND_SERVICE_TYPE_MANIFEST) {
-                    foregroundServiceType = resolveManifestServiceType();
+                  int requestedType = notificationModel.getAndroid().getForegroundServiceType();
+                  if (requestedType == ServiceInfo.FOREGROUND_SERVICE_TYPE_MANIFEST) {
+                    requestedType = resolveManifestServiceType();
                   }
                   if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE
-                      && foregroundServiceType == ServiceInfo.FOREGROUND_SERVICE_TYPE_NONE) {
+                      && requestedType == 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;
+                  } else if (requestedType != mCurrentForegroundServiceType) {
+                    foregroundServiceType = requestedType;
+                    shouldStartForeground = true;
                   }
                 }
-                if (shouldPostNotificationAgain) {
+                if (shouldStartForeground) {
+                  Trace.beginSection("notifee:startForeground");
+                  try {
+                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+                      startForeground(mCurrentHashCode, notification, foregroundServiceType);
+                    } else {
+                      startForeground(mCurrentHashCode, notification);
+                    }
+                  } finally {
+                    Trace.endSection();
+                  }
+                  mStartForegroundCalled = true;
+                } else {
                   NotificationManagerCompat.from(ContextHolder.getApplicationContext())
-                      .notify(hashCode, notification);
+                      .notify(mCurrentHashCode, notification);
                 }
+                // The platform call returned normally, so cache the latest submitted state for
+                // re-post and timeout. A normal return does not acknowledge display.
+                mCurrentForegroundServiceType = foregroundServiceType;
+                mCurrentNotification = notification;
+                mCurrentNotificationBundle = bundle;
               } else {
                 pendingEvent =
                     new NotificationEvent(

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

@@ -3,6 +3,7 @@ package app.notifee.core;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
@@ -17,6 +18,7 @@ import android.content.pm.PackageManager;
 import android.content.pm.ServiceInfo;
 import android.os.Bundle;
 import androidx.core.app.NotificationCompat;
+import app.notifee.core.event.ForegroundServiceEvent;
 import app.notifee.core.event.NotificationEvent;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
@@ -35,6 +37,7 @@ import org.robolectric.android.controller.ServiceController;
 import org.robolectric.annotation.Config;
 import org.robolectric.annotation.Implementation;
 import org.robolectric.annotation.Implements;
+import org.robolectric.shadows.ShadowNotificationManager;
 import org.robolectric.shadows.ShadowService;
 
 @RunWith(RobolectricTestRunner.class)
@@ -328,6 +331,473 @@ public class ForegroundServiceTest {
     assertEquals(id.hashCode(), hashField.getInt(null));
   }
 
+  @Test
+  @Config(sdk = 28)
+  public void onStartCommand_sameIdUpdate_refreshesRegisteredNotificationAndCachedState()
+      throws Exception {
+    createChannel();
+    ForegroundService service = Robolectric.buildService(ForegroundService.class).create().get();
+    String id = "live";
+    FgsRunnerCapture runnerCapture = new FgsRunnerCapture();
+    EventBus.register(runnerCapture);
+    try {
+      service.onStartCommand(buildStartIntent(id, id.hashCode(), "A"), 0, 1);
+      service.onStartCommand(buildStartIntent(id, id.hashCode(), "B"), 0, 2);
+
+      Notification registered =
+          org.robolectric.Shadows.shadowOf(service).getLastForegroundNotification();
+      NotificationManager manager =
+          (NotificationManager)
+              RuntimeEnvironment.getApplication().getSystemService(Context.NOTIFICATION_SERVICE);
+      Notification visible =
+          org.robolectric.Shadows.shadowOf(manager).getNotification(id.hashCode());
+      assertEquals("B", visible.extras.getString(Notification.EXTRA_TITLE));
+      assertEquals(1, org.robolectric.Shadows.shadowOf(manager).size());
+      assertEquals("B", registered.extras.getString(Notification.EXTRA_TITLE));
+      assertTrue((registered.flags & Notification.FLAG_ONLY_ALERT_ONCE) != 0);
+      assertEquals(
+          id.hashCode(),
+          org.robolectric.Shadows.shadowOf(service).getLastForegroundNotificationId());
+      assertEquals(
+          "B",
+          ((Notification) getPrivateStatic("mCurrentNotification"))
+              .extras.getString(Notification.EXTRA_TITLE));
+      assertEquals(
+          "B", ((Bundle) getPrivateStatic("mCurrentNotificationBundle")).getString("title"));
+      assertEquals(id, ForegroundService.mCurrentNotificationId);
+      assertEquals(id.hashCode(), getPrivateStatic("mCurrentHashCode"));
+      assertEquals(1, runnerCapture.events.size());
+    } finally {
+      EventBus.unregister(runnerCapture);
+    }
+  }
+
+  @Test
+  @Config(sdk = 29)
+  public void onStartCommand_sameIdUpdateApi29_preservesExplicitNoneTypeAndRegistration()
+      throws Exception {
+    createChannel();
+    ForegroundService service = Robolectric.buildService(ForegroundService.class).create().get();
+    String id = "live";
+
+    service.onStartCommand(
+        buildStartIntent(id, id.hashCode(), "A", ServiceInfo.FOREGROUND_SERVICE_TYPE_NONE), 0, 1);
+    service.onStartCommand(
+        buildStartIntent(id, id.hashCode(), "B", ServiceInfo.FOREGROUND_SERVICE_TYPE_NONE), 0, 2);
+
+    assertEquals(
+        "B",
+        org.robolectric.Shadows.shadowOf(service)
+            .getLastForegroundNotification()
+            .extras
+            .getString(Notification.EXTRA_TITLE));
+    assertEquals(ServiceInfo.FOREGROUND_SERVICE_TYPE_NONE, getLastForegroundServiceType(service));
+    assertEquals(
+        ServiceInfo.FOREGROUND_SERVICE_TYPE_NONE, ForegroundService.mCurrentForegroundServiceType);
+    assertEquals("B", ((Bundle) getPrivateStatic("mCurrentNotificationBundle")).getString("title"));
+  }
+
+  @Test
+  @Config(sdk = 30)
+  public void onStartCommand_sameIdUpdateApi30_keepsTypedForegroundService() throws Exception {
+    createChannel();
+    ForegroundService service = Robolectric.buildService(ForegroundService.class).create().get();
+    String id = "live";
+    service.onStartCommand(
+        buildStartIntent(id, id.hashCode(), "A", ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC),
+        0,
+        1);
+    service.onStartCommand(
+        buildStartIntent(id, id.hashCode(), "B", ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC),
+        0,
+        2);
+
+    assertEquals(
+        "B",
+        org.robolectric.Shadows.shadowOf(service)
+            .getLastForegroundNotification()
+            .extras
+            .getString(Notification.EXTRA_TITLE));
+    assertEquals(
+        ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC, getLastForegroundServiceType(service));
+    assertEquals(
+        ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC,
+        ForegroundService.mCurrentForegroundServiceType);
+  }
+
+  @Test
+  @Config(sdk = 29)
+  public void onStartCommand_sameIdUpdateApi29_preservesManifestFallbackType() throws Exception {
+    createChannel();
+    ForegroundService service = Robolectric.buildService(ForegroundService.class).create().get();
+    String id = "live";
+    service.onStartCommand(buildStartIntent(id, id.hashCode(), "A"), 0, 1);
+    service.onStartCommand(buildStartIntent(id, id.hashCode(), "B"), 0, 2);
+
+    assertEquals(
+        "B",
+        org.robolectric.Shadows.shadowOf(service)
+            .getLastForegroundNotification()
+            .extras
+            .getString(Notification.EXTRA_TITLE));
+    assertEquals(
+        ServiceInfo.FOREGROUND_SERVICE_TYPE_MANIFEST, getLastForegroundServiceType(service));
+    assertEquals(
+        ServiceInfo.FOREGROUND_SERVICE_TYPE_MANIFEST,
+        ForegroundService.mCurrentForegroundServiceType);
+  }
+
+  @Test
+  @Config(sdk = 34)
+  public void onStartCommand_sameIdTypeChange_usesLatestTypedNotificationAndCache()
+      throws Exception {
+    createChannel();
+    declareForegroundServiceTypes(
+        ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC
+            | ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK);
+    ForegroundService service = Robolectric.buildService(ForegroundService.class).create().get();
+    String id = "live";
+
+    service.onStartCommand(
+        buildStartIntent(id, id.hashCode(), "A", ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC),
+        0,
+        1);
+    service.onStartCommand(
+        buildStartIntent(
+            id, id.hashCode(), "B", ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK),
+        0,
+        2);
+
+    assertEquals(
+        "B",
+        org.robolectric.Shadows.shadowOf(service)
+            .getLastForegroundNotification()
+            .extras
+            .getString(Notification.EXTRA_TITLE));
+    assertEquals(
+        ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK, getLastForegroundServiceType(service));
+    assertEquals(
+        ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK,
+        ForegroundService.mCurrentForegroundServiceType);
+    assertEquals(
+        "B",
+        ((Notification) getPrivateStatic("mCurrentNotification"))
+            .extras.getString(Notification.EXTRA_TITLE));
+    assertEquals("B", ((Bundle) getPrivateStatic("mCurrentNotificationBundle")).getString("title"));
+  }
+
+  @Test
+  @Config(sdk = 33)
+  public void receiverDeleteAfterSameIdUpdate_repostsLatestNotificationWithoutDismissEvent()
+      throws Exception {
+    createChannel();
+    ForegroundService service = Robolectric.buildService(ForegroundService.class).create().get();
+    String id = "live";
+    service.onStartCommand(buildStartIntent(id, id.hashCode(), "A"), 0, 1);
+    service.onStartCommand(buildStartIntent(id, id.hashCode(), "B"), 0, 2);
+
+    NotificationManager manager =
+        (NotificationManager)
+            RuntimeEnvironment.getApplication().getSystemService(Context.NOTIFICATION_SERVICE);
+    manager.cancel(id.hashCode());
+    ReceiverService receiver = Robolectric.buildService(ReceiverService.class).create().get();
+    Intent delete = new Intent();
+    delete.setAction(ReceiverService.DELETE_INTENT);
+    delete.putExtra("notification", buildNotificationBundle(id));
+    FgsEventCapture capture = new FgsEventCapture();
+    EventBus.register(capture);
+    try {
+      receiver.onStartCommand(delete, 0, 3);
+      Notification reposted =
+          org.robolectric.Shadows.shadowOf(manager).getNotification(id.hashCode());
+      assertNotNull(reposted);
+      assertEquals("B", reposted.extras.getString(Notification.EXTRA_TITLE));
+      assertEquals(1, org.robolectric.Shadows.shadowOf(manager).size());
+      assertEquals(0, capture.events.size());
+    } finally {
+      EventBus.unregister(capture);
+    }
+  }
+
+  @Test
+  @Config(sdk = 34)
+  public void onTimeout_afterShortServiceSameIdUpdate_emitsLatestBundleWithoutRestart()
+      throws Exception {
+    createChannel();
+    declareForegroundServiceTypes(ServiceInfo.FOREGROUND_SERVICE_TYPE_SHORT_SERVICE);
+    ForegroundService service = Robolectric.buildService(ForegroundService.class).create().get();
+    String id = "live";
+    service.onStartCommand(
+        buildStartIntent(id, id.hashCode(), "A", ServiceInfo.FOREGROUND_SERVICE_TYPE_SHORT_SERVICE),
+        0,
+        1);
+    service.onStartCommand(
+        buildStartIntent(id, id.hashCode(), "B", ServiceInfo.FOREGROUND_SERVICE_TYPE_SHORT_SERVICE),
+        0,
+        2);
+
+    NotificationManager manager =
+        (NotificationManager)
+            RuntimeEnvironment.getApplication().getSystemService(Context.NOTIFICATION_SERVICE);
+    assertEquals(
+        "B",
+        org.robolectric.Shadows.shadowOf(manager)
+            .getNotification(id.hashCode())
+            .extras
+            .getString(Notification.EXTRA_TITLE));
+    // Robolectric does not model Android 12+ notify-to-FGS synchronization. Its service shadow
+    // remains at A here, which also guards against resetting shortService's timer via a repeat
+    // startForeground call.
+    assertEquals(
+        "A",
+        org.robolectric.Shadows.shadowOf(service)
+            .getLastForegroundNotification()
+            .extras
+            .getString(Notification.EXTRA_TITLE));
+    FgsEventCapture capture = new FgsEventCapture();
+    EventBus.register(capture);
+    try {
+      service.onTimeout(42);
+      assertEquals(1, capture.events.size());
+      assertEquals(NotificationEvent.TYPE_FG_TIMEOUT, capture.events.get(0).getType());
+      assertEquals("B", capture.events.get(0).getNotification().getTitle());
+    } finally {
+      EventBus.unregister(capture);
+    }
+  }
+
+  @Test
+  @Config(sdk = 33)
+  public void onStartCommand_differentId_emitsAlreadyExistsAndKeepsActiveState() throws Exception {
+    createChannel();
+    ForegroundService service = Robolectric.buildService(ForegroundService.class).create().get();
+    String id = "live";
+    service.onStartCommand(buildStartIntent(id, id.hashCode(), "A"), 0, 1);
+    FgsEventCapture capture = new FgsEventCapture();
+    EventBus.register(capture);
+    try {
+      service.onStartCommand(buildStartIntent("other", "other".hashCode(), "B"), 0, 2);
+      assertEquals(1, capture.events.size());
+      assertEquals(NotificationEvent.TYPE_FG_ALREADY_EXIST, capture.events.get(0).getType());
+      assertEquals(id, ForegroundService.mCurrentNotificationId);
+      assertEquals(
+          "A", ((Bundle) getPrivateStatic("mCurrentNotificationBundle")).getString("title"));
+      NotificationManager manager =
+          (NotificationManager)
+              RuntimeEnvironment.getApplication().getSystemService(Context.NOTIFICATION_SERVICE);
+      assertEquals(1, org.robolectric.Shadows.shadowOf(manager).size());
+    } finally {
+      EventBus.unregister(capture);
+    }
+  }
+
+  @Test
+  @Config(sdk = 28, shadows = RejectBStartForegroundShadowService.class)
+  public void onStartCommand_sameTypeStartForegroundFailure_keepsPreviousCache() throws Exception {
+    createChannel();
+    ForegroundService service = Robolectric.buildService(ForegroundService.class).create().get();
+    String id = "live";
+    service.onStartCommand(buildStartIntent(id, id.hashCode(), "A"), 0, 1);
+
+    SecurityException failure =
+        assertThrows(
+            SecurityException.class,
+            () -> service.onStartCommand(buildStartIntent(id, id.hashCode(), "B"), 0, 2));
+    assertEquals("posting B rejected", failure.getMessage());
+
+    assertEquals(id, ForegroundService.mCurrentNotificationId);
+    assertEquals(id.hashCode(), getPrivateStatic("mCurrentHashCode"));
+    assertEquals("A", ((Bundle) getPrivateStatic("mCurrentNotificationBundle")).getString("title"));
+    assertEquals(
+        "A",
+        ((Notification) getPrivateStatic("mCurrentNotification"))
+            .extras.getString(Notification.EXTRA_TITLE));
+  }
+
+  @Test
+  @Config(sdk = 28, shadows = RejectBStartForegroundShadowService.class)
+  public void onStartCommand_initialStartForegroundFailure_doesNotClaimActiveService()
+      throws Exception {
+    createChannel();
+    ForegroundService service = Robolectric.buildService(ForegroundService.class).create().get();
+    String id = "live";
+    FgsRunnerCapture runnerCapture = new FgsRunnerCapture();
+    EventBus.register(runnerCapture);
+    try {
+      SecurityException failure =
+          assertThrows(
+              SecurityException.class,
+              () -> service.onStartCommand(buildStartIntent(id, id.hashCode(), "B"), 0, 1));
+      assertEquals("posting B rejected", failure.getMessage());
+      assertNull(ForegroundService.mCurrentNotificationId);
+      assertNull(getPrivateStatic("mCurrentNotification"));
+      assertNull(getPrivateStatic("mCurrentNotificationBundle"));
+      assertEquals(0, getPrivateStatic("mCurrentHashCode"));
+      assertEquals(0, runnerCapture.events.size());
+
+      service.onStartCommand(buildStartIntent(id, id.hashCode(), "A"), 0, 2);
+      assertEquals(1, runnerCapture.events.size());
+      assertEquals(
+          "A", ((Bundle) getPrivateStatic("mCurrentNotificationBundle")).getString("title"));
+    } finally {
+      EventBus.unregister(runnerCapture);
+    }
+  }
+
+  @Test
+  @Config(sdk = 34, shadows = RejectBStartForegroundShadowService.class)
+  public void onStartCommand_typeChangeStartForegroundFailure_keepsPreviousTypeAndCache()
+      throws Exception {
+    createChannel();
+    declareForegroundServiceTypes(
+        ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC
+            | ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK);
+    ForegroundService service = Robolectric.buildService(ForegroundService.class).create().get();
+    String id = "live";
+    service.onStartCommand(
+        buildStartIntent(id, id.hashCode(), "A", ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC),
+        0,
+        1);
+
+    SecurityException failure =
+        assertThrows(
+            SecurityException.class,
+            () ->
+                service.onStartCommand(
+                    buildStartIntent(
+                        id, id.hashCode(), "B", ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK),
+                    0,
+                    2));
+    assertEquals("posting B rejected", failure.getMessage());
+
+    assertEquals(
+        ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC,
+        ForegroundService.mCurrentForegroundServiceType);
+    assertEquals("A", ((Bundle) getPrivateStatic("mCurrentNotificationBundle")).getString("title"));
+    assertEquals(
+        "A",
+        ((Notification) getPrivateStatic("mCurrentNotification"))
+            .extras.getString(Notification.EXTRA_TITLE));
+  }
+
+  @Test
+  @Config(sdk = 33, shadows = RejectBNotificationShadowManager.class)
+  public void onStartCommand_notifyFailure_keepsPreviousCache() throws Exception {
+    createChannel();
+    ForegroundService service = Robolectric.buildService(ForegroundService.class).create().get();
+    String id = "live";
+    service.onStartCommand(buildStartIntent(id, id.hashCode(), "A"), 0, 1);
+
+    SecurityException failure =
+        assertThrows(
+            SecurityException.class,
+            () -> service.onStartCommand(buildStartIntent(id, id.hashCode(), "B"), 0, 2));
+    assertEquals("posting B rejected", failure.getMessage());
+
+    assertEquals(id, ForegroundService.mCurrentNotificationId);
+    assertEquals(id.hashCode(), getPrivateStatic("mCurrentHashCode"));
+    assertEquals("A", ((Bundle) getPrivateStatic("mCurrentNotificationBundle")).getString("title"));
+    assertEquals(
+        "A",
+        ((Notification) getPrivateStatic("mCurrentNotification"))
+            .extras.getString(Notification.EXTRA_TITLE));
+  }
+
+  @Test
+  @Config(sdk = 34, shadows = SilentlyRejectMissingChannelShadowManager.class)
+  public void onStartCommand_notifyReturnsNormallyWithoutPosting_keepsLatestSubmittedState()
+      throws Exception {
+    createChannel();
+    declareForegroundServiceTypes(ServiceInfo.FOREGROUND_SERVICE_TYPE_SHORT_SERVICE);
+    ForegroundService service = Robolectric.buildService(ForegroundService.class).create().get();
+    String id = "live";
+    service.onStartCommand(
+        buildStartIntent(id, id.hashCode(), "A", ServiceInfo.FOREGROUND_SERVICE_TYPE_SHORT_SERVICE),
+        0,
+        1);
+
+    Intent update =
+        buildStartIntent(id, id.hashCode(), "B", ServiceInfo.FOREGROUND_SERVICE_TYPE_SHORT_SERVICE);
+    String missingChannelId = "missing-channel";
+    Notification rejected =
+        new NotificationCompat.Builder(RuntimeEnvironment.getApplication(), missingChannelId)
+            .setSmallIcon(android.R.drawable.ic_dialog_info)
+            .setContentTitle("B")
+            .setOnlyAlertOnce(true)
+            .build();
+    update.putExtra("notification", rejected);
+    update
+        .getBundleExtra("notificationBundle")
+        .getBundle("android")
+        .putString("channelId", missingChannelId);
+
+    NotificationManager manager =
+        (NotificationManager)
+            RuntimeEnvironment.getApplication().getSystemService(Context.NOTIFICATION_SERVICE);
+    assertNull(manager.getNotificationChannel(missingChannelId));
+    SilentlyRejectMissingChannelShadowManager.rejectedPosts = 0;
+    SilentlyRejectMissingChannelShadowManager.lastRejectedNotification = null;
+    service.onStartCommand(update, 0, 2);
+
+    // This shadow models the platform's normal-return, no-post outcome. Robolectric does not
+    // reproduce the separate Android foreground-service record update in this sequence.
+    assertEquals(1, SilentlyRejectMissingChannelShadowManager.rejectedPosts);
+    assertEquals(
+        "B",
+        SilentlyRejectMissingChannelShadowManager.lastRejectedNotification.extras.getString(
+            Notification.EXTRA_TITLE));
+    assertEquals(
+        "A",
+        org.robolectric.Shadows.shadowOf(manager)
+            .getNotification(id.hashCode())
+            .extras
+            .getString(Notification.EXTRA_TITLE));
+    // The simulated visible card remains A while NotifyKit's latest submitted state is B.
+    assertEquals("B", ((Bundle) getPrivateStatic("mCurrentNotificationBundle")).getString("title"));
+    assertEquals(
+        "B",
+        ((Notification) getPrivateStatic("mCurrentNotification"))
+            .extras.getString(Notification.EXTRA_TITLE));
+    assertEquals(
+        ServiceInfo.FOREGROUND_SERVICE_TYPE_SHORT_SERVICE,
+        ForegroundService.mCurrentForegroundServiceType);
+    assertEquals(id, ForegroundService.mCurrentNotificationId);
+    assertEquals(id.hashCode(), getPrivateStatic("mCurrentHashCode"));
+    // The service shadow remains at A because the unchanged-type path did not call
+    // startForeground() again, which could extend a shortService timeout on Android.
+    assertEquals(
+        "A",
+        org.robolectric.Shadows.shadowOf(service)
+            .getLastForegroundNotification()
+            .extras
+            .getString(Notification.EXTRA_TITLE));
+
+    manager.cancel(id.hashCode());
+    ReceiverService receiver = Robolectric.buildService(ReceiverService.class).create().get();
+    Intent delete = new Intent();
+    delete.setAction(ReceiverService.DELETE_INTENT);
+    delete.putExtra("notification", buildNotificationBundle(id));
+    FgsEventCapture capture = new FgsEventCapture();
+    EventBus.register(capture);
+    try {
+      receiver.onStartCommand(delete, 0, 3);
+      assertEquals(2, SilentlyRejectMissingChannelShadowManager.rejectedPosts);
+      assertEquals(
+          "B",
+          SilentlyRejectMissingChannelShadowManager.lastRejectedNotification.extras.getString(
+              Notification.EXTRA_TITLE));
+      assertNull(org.robolectric.Shadows.shadowOf(manager).getNotification(id.hashCode()));
+      assertEquals(0, capture.events.size());
+
+      service.onTimeout(42);
+      assertEquals(1, capture.events.size());
+      assertEquals(NotificationEvent.TYPE_FG_TIMEOUT, capture.events.get(0).getType());
+      assertEquals("B", capture.events.get(0).getNotification().getTitle());
+    } finally {
+      EventBus.unregister(capture);
+    }
+  }
+
   /**
    * Regression guard for the 9.1.13 {@code onTimeout(int)} fix (upstream invertase/notifee#703). On
    * API 34, Android's single-argument {@code onTimeout} fires when a {@code shortService} FGS
@@ -473,11 +943,35 @@ public class ForegroundServiceTest {
   }
 
   private static Intent buildStartIntent(String id, int hashCode) {
+    return buildStartIntent(id, hashCode, "FGS test");
+  }
+
+  private static Intent buildStartIntent(String id, int hashCode, String title) {
     Intent intent = new Intent();
     intent.setAction(ForegroundService.START_FOREGROUND_SERVICE_ACTION);
     intent.putExtra("hashCode", hashCode);
-    intent.putExtra("notification", buildNotification());
-    intent.putExtra("notificationBundle", buildNotificationBundle(id));
+    Notification notification =
+        new NotificationCompat.Builder(RuntimeEnvironment.getApplication(), TEST_CHANNEL_ID)
+            .setSmallIcon(android.R.drawable.ic_dialog_info)
+            .setContentTitle(title)
+            .setOnlyAlertOnce(true)
+            .build();
+    intent.putExtra("notification", notification);
+    Bundle bundle = buildNotificationBundle(id);
+    bundle.putString("title", title);
+    intent.putExtra("notificationBundle", bundle);
+    return intent;
+  }
+
+  private static Intent buildStartIntent(
+      String id, int hashCode, String title, int foregroundServiceType) {
+    Intent intent = buildStartIntent(id, hashCode, title);
+    Bundle bundle = intent.getBundleExtra("notificationBundle");
+    Bundle android = bundle.getBundle("android");
+    ArrayList<Integer> types = new ArrayList<>();
+    types.add(foregroundServiceType);
+    android.putIntegerArrayList("foregroundServiceTypes", types);
+    intent.putExtra("notificationBundle", bundle);
     return intent;
   }
 
@@ -538,6 +1032,67 @@ public class ForegroundServiceTest {
     field.set(null, value);
   }
 
+  private static Object getPrivateStatic(String name) throws Exception {
+    Field field = ForegroundService.class.getDeclaredField(name);
+    field.setAccessible(true);
+    return field.get(null);
+  }
+
+  public static class FgsRunnerCapture {
+    final List<ForegroundServiceEvent> events = new ArrayList<>();
+
+    @Subscribe(threadMode = ThreadMode.POSTING)
+    public void onForegroundServiceEvent(ForegroundServiceEvent event) {
+      events.add(event);
+    }
+  }
+
+  @Implements(Service.class)
+  public static class RejectBStartForegroundShadowService extends ShadowService {
+    @Implementation
+    protected void startForeground(int id, Notification notification) {
+      if ("B".equals(notification.extras.getString(Notification.EXTRA_TITLE))) {
+        throw new SecurityException("posting B rejected");
+      }
+      super.startForeground(id, notification);
+    }
+
+    @Implementation
+    protected void startForeground(int id, Notification notification, int foregroundServiceType) {
+      if ("B".equals(notification.extras.getString(Notification.EXTRA_TITLE))) {
+        throw new SecurityException("posting B rejected");
+      }
+      super.startForeground(id, notification, foregroundServiceType);
+    }
+  }
+
+  @Implements(NotificationManager.class)
+  public static class RejectBNotificationShadowManager extends ShadowNotificationManager {
+    @Implementation
+    protected void notify(String tag, int id, Notification notification) {
+      if ("B".equals(notification.extras.getString(Notification.EXTRA_TITLE))) {
+        throw new SecurityException("posting B rejected");
+      }
+      super.notify(tag, id, notification);
+    }
+  }
+
+  @Implements(NotificationManager.class)
+  public static class SilentlyRejectMissingChannelShadowManager extends ShadowNotificationManager {
+    static int rejectedPosts;
+    static Notification lastRejectedNotification;
+
+    @Implementation
+    protected void notify(String tag, int id, Notification notification) {
+      if ("missing-channel".equals(notification.getChannelId())) {
+        rejectedPosts++;
+        lastRejectedNotification = notification;
+        return;
+      }
+      super.notify(tag, id, notification);
+    }
+  }
+
   /**
    * greenrobot EventBus subscriber that records every {@link NotificationEvent} posted during a
    * test. {@link ThreadMode#POSTING} fires the subscriber synchronously on the caller thread, so

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "10.7.1";
+export declare const version = "10.7.2";

package/dist/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-notify-kit",
-  "version": "10.7.1",
+  "version": "10.7.2",
   "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.7.1';
+export const version = '10.7.2';