react-native-notify-kit 10.0.0 → 10.2.0

package/android/build.gradle

@@ -53,7 +53,7 @@ android {
   defaultConfig {
     minSdk = 24
     targetSdk = 35
-    multiDexEnabled true
+    multiDexEnabled = true
 
     testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
 
@@ -66,7 +66,7 @@ android {
 
   lint {
     disable 'GradleCompatible'
-    abortOnError false
+    abortOnError = false
   }
 
   compileOptions {

package/android/src/androidTest/java/app/notifee/core/RebootRecoveryTest.java

@@ -14,8 +14,8 @@ package app.notifee.core;
  * NOT RUN IN CI.
  *
  * Instrumented regression suite for the reboot-recovery path in
- * NotifeeAlarmManager.rescheduleNotifications, covering three upstream
- * issues across five test cases:
+ * NotifeeAlarmManager.rescheduleNotifications, covering four upstream
+ * issues across six test cases:
  *
  *   1. rescheduleNotifications_advancesEveryAnchorBeforeCompleting
  *      (upstream invertase/notifee#549 — reboot-recovery anchor persistence
@@ -54,6 +54,15 @@ package app.notifee.core;
  *      handleStaleNonRepeatingTrigger routes the failure through the
  *      resilient branch that still runs deleteById.
  *
+ *   6. rescheduleNotifications_nonRepeatingFuture_preservesAnchorAndRearmsAlarm
+ *      (upstream invertase/notifee#991 — non-repeating TIMESTAMP triggers lost
+ *      after device reboot on Android 14). Seeds a non-repeating row 5 minutes
+ *      in the future and asserts the row survives reboot recovery with its
+ *      anchor preserved AND a fresh AlarmManager PendingIntent registered.
+ *      Complements the past-stale paths above by covering the happy-path
+ *      branch where setNextTimestamp early-returns at TimestampTriggerModel:136
+ *      and rescheduleNotification re-arms the original anchor.
+ *
  * Run manually via the smoke harness (recommended — wraps gradle + copies
  * reports + fails loud if no XML reports are found):
  *
@@ -133,6 +142,9 @@ public class RebootRecoveryTest {
   /** 48 hours before "now" — well beyond the 24h grace period. */
   private static final long STALE_BEYOND_GRACE_OFFSET_MS = 48 * HOUR_IN_MS;
 
+  /** 5 minutes after "now" — the future-non-repeating happy path for upstream #991. */
+  private static final long FUTURE_NON_REPEATING_OFFSET_MS = 5L * 60 * 1000;
+
   /**
    * Channel id used by the within-grace stale-trigger test fixture. Must match a real Android
    * notification channel created in {@link #setUp()} so {@code
@@ -181,6 +193,7 @@ public class RebootRecoveryTest {
     NotifeeAlarmManager.cancelNotification(staleWithinGraceTestId());
     NotifeeAlarmManager.cancelNotification(staleBeyondGraceTestId());
     NotifeeAlarmManager.cancelNotification(staleDisplayFailsTestId());
+    NotifeeAlarmManager.cancelNotification(nonRepeatingFutureTestId());
     // Dismiss any notifications the within-grace tests may have posted so the device
     // notification shade is left clean — the Room row is the test's contract, but the
     // visible notification is a side effect we should not leave behind.
@@ -387,6 +400,81 @@ public class RebootRecoveryTest {
         repo.getWorkDataById(id).get(5, TimeUnit.SECONDS) == null);
   }
 
+  /**
+   * Regression test for upstream invertase/notifee#991 — non-repeating TIMESTAMP triggers whose
+   * fire time is still in the future at boot must be re-armed with their original anchor preserved.
+   *
+   * <p>The existing #734 tests cover the past-stale branches of {@code
+   * handleStaleNonRepeatingTrigger}; this fills the happy-path gap. Seeds a non-repeating trigger 5
+   * minutes in the future, invokes reboot recovery, and asserts that:
+   *
+   * <ul>
+   *   <li>the Room row survives (not stale → not deleted),
+   *   <li>the timestamp is unchanged (non-repeating → {@code setNextTimestamp} early-returns at
+   *       {@code TimestampTriggerModel.java:136-139}),
+   *   <li>an {@code AlarmManager} {@code PendingIntent} has been re-registered for the row, proving
+   *       {@code rescheduleNotification} → {@code scheduleTimestampTriggerNotification} reached the
+   *       alarm-set call.
+   * </ul>
+   */
+  @Test
+  public void rescheduleNotifications_nonRepeatingFuture_preservesAnchorAndRearmsAlarm()
+      throws Exception {
+    long now = System.currentTimeMillis();
+    long futureAnchor = now + FUTURE_NON_REPEATING_OFFSET_MS;
+    String id = nonRepeatingFutureTestId();
+
+    repo.insert(buildNonRepeatingEntity(id, futureAnchor)).get(5, TimeUnit.SECONDS);
+    assertEquals(1, repo.getAll().get(5, TimeUnit.SECONDS).size());
+
+    new NotifeeAlarmManager().rescheduleNotifications(null);
+
+    PendingIntent pi = awaitPendingIntentRegistered(id);
+    assertNotNull(
+        "AlarmManager PendingIntent must be re-registered for the non-repeating future row " + id,
+        pi);
+
+    WorkDataEntity row = repo.getWorkDataById(id).get(5, TimeUnit.SECONDS);
+    assertNotNull("non-repeating future row must survive reboot recovery", row);
+    Bundle triggerBundle = ObjectUtils.bytesToBundle(row.getTrigger());
+    long preservedAnchor = ObjectUtils.getLong(triggerBundle.get("timestamp"));
+    assertEquals(
+        "non-repeating future trigger anchor must NOT be advanced — setNextTimestamp early-returns"
+            + " when repeatFrequency is -1 and timestamp is in the future",
+        futureAnchor,
+        preservedAnchor);
+  }
+
+  /**
+   * Polls until an {@code AlarmManager} {@code PendingIntent} keyed off {@code id.hashCode()} is
+   * registered (FLAG_NO_CREATE returns non-null). Times out via {@link #fail(String)} if the
+   * reschedule pass never reaches {@code alarmManager.set*}.
+   */
+  private PendingIntent awaitPendingIntentRegistered(String id) throws Exception {
+    Intent intent = new Intent(context, NotificationAlarmReceiver.class);
+    intent.putExtra("notificationId", id);
+    long deadline = System.currentTimeMillis() + POLL_DEADLINE_MS;
+    while (System.currentTimeMillis() < deadline) {
+      PendingIntent pi =
+          PendingIntent.getBroadcast(
+              context,
+              id.hashCode(),
+              intent,
+              PendingIntent.FLAG_NO_CREATE | PendingIntent.FLAG_MUTABLE);
+      if (pi != null) {
+        return pi;
+      }
+      Thread.sleep(POLL_INTERVAL_MS);
+    }
+    fail(
+        "AlarmManager PendingIntent for "
+            + id
+            + " was not registered within "
+            + POLL_DEADLINE_MS
+            + "ms — the #991 fix in rescheduleNotification may be broken");
+    return null; // unreachable
+  }
+
   /** Polls {@link WorkDataRepository#getWorkDataById(String)} until it returns {@code null}. */
   private void awaitRowDeleted(String id) throws Exception {
     long deadline = System.currentTimeMillis() + POLL_DEADLINE_MS;
@@ -566,4 +654,8 @@ public class RebootRecoveryTest {
   private static String staleDisplayFailsTestId() {
     return "reboot-recovery-stale-display-fails-test";
   }
+
+  private static String nonRepeatingFutureTestId() {
+    return "reboot-recovery-non-repeating-future-test";
+  }
 }

package/android/src/main/AndroidManifest.xml

@@ -49,15 +49,16 @@
       </intent-filter>
     </receiver>
 
+    <!--
+      NotificationAlarmReceiver is invoked exclusively via PendingIntent broadcasts from
+      AlarmManager (NotifeeAlarmManager.scheduleTimestampTriggerNotification). It does not
+      handle any system-broadcast Intent action — onReceive dispatches intent.getExtras()
+      to NotifeeAlarmManager.displayScheduledNotification, which early-returns on null
+      extras. Reboot recovery is owned by RebootBroadcastReceiver above.
+    -->
     <receiver
       android:name="app.notifee.core.NotificationAlarmReceiver"
-      android:exported="false">
-      <intent-filter>
-        <action android:name="android.intent.action.BOOT_COMPLETED" />
-        <action android:name="android.intent.action.QUICKBOOT_POWERON" />
-        <action android:name="com.htc.intent.action.QUICKBOOT_POWERON"/>
-      </intent-filter>
-    </receiver>
+      android:exported="false" />
 
     <!-- Broadcast Receiver -->
     <receiver

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

@@ -415,6 +415,7 @@ public class ForegroundService extends Service {
    * @return the raw {@code foregroundServiceType} bitmask from the manifest, or 0 if the service is
    *     not declared or has no explicit type
    */
+  @RequiresApi(Build.VERSION_CODES.Q)
   private int getDeclaredForegroundServiceType() {
     try {
       ComponentName component = new ComponentName(this, ForegroundService.class);

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

@@ -312,6 +312,8 @@ class NotificationManager {
               } else {
                 builder.setSmallIcon(smallIconId);
               }
+            } else {
+              builder.setSmallIcon(ResourceUtils.getFallbackSmallIconId(getApplicationContext()));
             }
 
             if (androidModel.getSortKey() != null) {
@@ -816,6 +818,12 @@ class NotificationManager {
     Boolean withAlarmManager = trigger.getWithAlarmManager();
     Context context = getApplicationContext();
 
+    if (!withAlarmManager && TimestampTriggerModel.MONTHLY.equals(trigger.getRepeatFrequency())) {
+      String message = "RepeatFrequency.MONTHLY is not supported without AlarmManager.";
+      Logger.e(TAG, message);
+      return Futures.immediateFailedFuture(new IllegalArgumentException(message));
+    }
+
     ListenableFuture<Void> insertFuture =
         WorkDataRepository.insertTriggerNotification(
             context, notificationModel, triggerBundle, withAlarmManager);

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

@@ -27,9 +27,25 @@ import android.content.Intent;
  */
 public class RebootBroadcastReceiver extends BroadcastReceiver {
   private static final String TAG = "RebootReceiver";
+  private static final String ACTION_QUICKBOOT_POWERON = "android.intent.action.QUICKBOOT_POWERON";
+  private static final String ACTION_HTC_QUICKBOOT_POWERON =
+      "com.htc.intent.action.QUICKBOOT_POWERON";
 
   @Override
   public void onReceive(Context context, Intent intent) {
+    if (intent == null) {
+      Logger.w(TAG, "Ignoring reboot event with null intent");
+      return;
+    }
+
+    String action = intent.getAction();
+    if (!Intent.ACTION_BOOT_COMPLETED.equals(action)
+        && !ACTION_QUICKBOOT_POWERON.equals(action)
+        && !ACTION_HTC_QUICKBOOT_POWERON.equals(action)) {
+      Logger.w(TAG, "Ignoring unsupported reboot event action: " + action);
+      return;
+    }
+
     PendingResult pendingResult = goAsync();
     // Tracks whether the synchronous section successfully handed off to the
     // async reschedule path. If not, the finally block must call finish() to

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

@@ -533,9 +533,14 @@ public class NotificationAndroidModel {
     int smallIconId = ResourceUtils.getImageResourceId(rawIcon);
 
     if (smallIconId == 0) {
-      Logger.d(
-          "NotificationAndroidModel",
-          String.format("Notification small icon '%s' could not be found", rawIcon));
+      Logger.w(
+          TAG,
+          String.format(
+              "Notification small icon '%s' could not be resolved; falling back to the app"
+                  + " launcher icon. Common causes: asset only in src/debug/res, R8 resource"
+                  + " shrinking, or name mismatch (names must be lowercase with underscores)."
+                  + " See README Troubleshooting.",
+              rawIcon));
       return null;
     }
 

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

@@ -30,13 +30,13 @@ public class TimestampTriggerModel {
   private Boolean mWithAlarmManager = false;
   private AlarmType mAlarmType = AlarmType.SET_EXACT;
   private String mRepeatFrequency = null;
+  private int mRepeatInterval = 1;
   private Long mTimestamp = null;
 
   public static final String HOURLY = "HOURLY";
   public static final String DAILY = "DAILY";
   public static final String WEEKLY = "WEEKLY";
-
-  private static final long HOUR_IN_MS = 60L * 60 * 1000;
+  public static final String MONTHLY = "MONTHLY";
 
   private static final String TAG = "TimeTriggerModel";
 
@@ -47,6 +47,7 @@ public class TimestampTriggerModel {
     TimeUnit timeUnit = null;
     if (mTimeTriggerBundle.containsKey("repeatFrequency")) {
       int repeatFrequency = ObjectUtils.getInt(mTimeTriggerBundle.get("repeatFrequency"));
+      mRepeatInterval = getRepeatInterval(mTimeTriggerBundle.get("repeatInterval"));
       mTimestamp = ObjectUtils.getLong(mTimeTriggerBundle.get("timestamp"));
 
       switch (repeatFrequency) {
@@ -54,21 +55,24 @@ public class TimestampTriggerModel {
           // default value for one-time trigger
           break;
         case 0:
-          mInterval = 1;
+          mInterval = mRepeatInterval;
           mTimeUnit = TimeUnit.HOURS;
           mRepeatFrequency = HOURLY;
           break;
         case 1:
-          mInterval = 1;
+          mInterval = mRepeatInterval;
           mTimeUnit = TimeUnit.DAYS;
           mRepeatFrequency = DAILY;
           break;
         case 2:
           // weekly, 7 days
-          mInterval = 7;
+          mInterval = 7 * mRepeatInterval;
           mTimeUnit = TimeUnit.DAYS;
           mRepeatFrequency = WEEKLY;
           break;
+        case 3:
+          mRepeatFrequency = MONTHLY;
+          break;
       }
     }
 
@@ -139,33 +143,27 @@ public class TimestampTriggerModel {
       return;
     }
 
-    long timestamp = getTimestamp();
+    Calendar cal = Calendar.getInstance();
+    cal.setTimeInMillis(getTimestamp());
 
+    int field;
     if (HOURLY.equals(mRepeatFrequency)) {
-      // Hourly: fixed ms is correct — no wall-clock preservation needed
-      while (timestamp < System.currentTimeMillis()) {
-        timestamp += HOUR_IN_MS;
-      }
-      this.mTimestamp = timestamp;
+      field = Calendar.HOUR_OF_DAY;
+    } else if (DAILY.equals(mRepeatFrequency)) {
+      field = Calendar.DAY_OF_MONTH;
+    } else if (WEEKLY.equals(mRepeatFrequency)) {
+      field = Calendar.WEEK_OF_YEAR;
+    } else if (MONTHLY.equals(mRepeatFrequency)) {
+      field = Calendar.MONTH;
     } else {
-      // Daily/Weekly: use Calendar.add() to preserve local wall-clock time across DST boundaries.
-      // Adding fixed ms (86,400,000) breaks when a calendar day is 23 or 25 hours during DST.
-      Calendar cal = Calendar.getInstance();
-      cal.setTimeInMillis(timestamp);
-
-      int field;
-      if (WEEKLY.equals(mRepeatFrequency)) {
-        field = Calendar.WEEK_OF_YEAR;
-      } else {
-        field = Calendar.DAY_OF_MONTH;
-      }
-
-      while (cal.getTimeInMillis() < System.currentTimeMillis()) {
-        cal.add(field, 1);
-      }
+      return;
+    }
 
-      this.mTimestamp = cal.getTimeInMillis();
+    while (cal.getTimeInMillis() < System.currentTimeMillis()) {
+      cal.add(field, mRepeatInterval);
     }
+
+    this.mTimestamp = cal.getTimeInMillis();
   }
 
   public enum AlarmType {
@@ -196,6 +194,23 @@ public class TimestampTriggerModel {
     return mRepeatFrequency;
   }
 
+  private int getRepeatInterval(Object repeatInterval) {
+    if (!(repeatInterval instanceof Number)) {
+      return 1;
+    }
+
+    double interval = ((Number) repeatInterval).doubleValue();
+    if (Double.isNaN(interval)
+        || Double.isInfinite(interval)
+        || interval <= 0
+        || interval % 1 != 0
+        || interval > Integer.MAX_VALUE) {
+      return 1;
+    }
+
+    return (int) interval;
+  }
+
   public Bundle toBundle() {
     Bundle bundle = (Bundle) mTimeTriggerBundle.clone();
     if (mTimestamp != null) {

package/android/src/main/java/app/notifee/core/utility/ResourceUtils.java

@@ -18,6 +18,7 @@ package app.notifee.core.utility;
  */
 
 import android.content.Context;
+import android.content.pm.ApplicationInfo;
 import android.graphics.Bitmap;
 import android.graphics.Canvas;
 import android.graphics.Color;
@@ -43,6 +44,7 @@ import com.facebook.imagepipeline.request.ImageRequestBuilder;
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.SettableFuture;
 import java.util.HashMap;
+import java.util.Locale;
 import java.util.Map;
 
 public class ResourceUtils {
@@ -223,13 +225,40 @@ public class ResourceUtils {
     return resourceId;
   }
 
+  /**
+   * Returns a resource id guaranteed to be usable as a smallIcon. Three-layer fallback: (1) {@code
+   * applicationInfo.icon}, (2) {@code applicationInfo.logo}, (3) the system {@code
+   * android.R.drawable.ic_dialog_info} drawable. Never returns 0, never throws.
+   *
+   * <p>Used by {@link app.notifee.core.NotificationManager} to keep a notification valid when the
+   * user-supplied {@code smallIcon} string cannot be resolved to a drawable at runtime.
+   */
+  public static int getFallbackSmallIconId(Context context) {
+    try {
+      if (context != null) {
+        ApplicationInfo info = context.getApplicationInfo();
+        if (info != null) {
+          if (info.icon != 0) {
+            return info.icon;
+          }
+          if (info.logo != 0) {
+            return info.logo;
+          }
+        }
+      }
+    } catch (Exception e) {
+      Logger.w(TAG, "getFallbackSmallIconId -> falling back to system default icon", e);
+    }
+    return android.R.drawable.ic_dialog_info;
+  }
+
   /** Attempts to find a resource id by name and type */
   private static int getResourceIdByName(String name, String type) {
     if (name == null || name.isEmpty()) {
       return 0;
     }
 
-    name = name.toLowerCase().replace("-", "_");
+    name = name.toLowerCase(Locale.ROOT).replace("-", "_");
 
     String key = name + "_" + type;
 

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

@@ -157,7 +157,7 @@ class NotifeeApiModule(reactContext: ReactApplicationContext) :
 
     override fun openAlarmPermissionSettings(promise: Promise) {
         Notifee.getInstance()
-            .openAlarmPermissionSettings(getCurrentActivity()) { e, _ ->
+            .openAlarmPermissionSettings(getReactApplicationContext().getCurrentActivity()) { e, _ ->
                 NotifeeReactUtils.promiseResolver(promise, e)
             }
     }
@@ -220,7 +220,7 @@ class NotifeeApiModule(reactContext: ReactApplicationContext) :
 
     override fun getInitialNotification(promise: Promise) {
         Notifee.getInstance()
-            .getInitialNotification(getCurrentActivity()) { e, bundle ->
+            .getInitialNotification(getReactApplicationContext().getCurrentActivity()) { e, bundle ->
                 NotifeeReactUtils.promiseResolver(promise, e, bundle)
             }
     }
@@ -242,7 +242,7 @@ class NotifeeApiModule(reactContext: ReactApplicationContext) :
             return
         }
 
-        val activity = getCurrentActivity() as? PermissionAwareActivity
+        val activity = getReactApplicationContext().getCurrentActivity() as? PermissionAwareActivity
         if (activity == null) {
             Logger.d(
                 "requestPermission",
@@ -277,14 +277,14 @@ class NotifeeApiModule(reactContext: ReactApplicationContext) :
 
     override fun openNotificationSettings(channelId: String?, promise: Promise) {
         Notifee.getInstance()
-            .openNotificationSettings(channelId, getCurrentActivity()) { e, _ ->
+            .openNotificationSettings(channelId, getReactApplicationContext().getCurrentActivity()) { e, _ ->
                 NotifeeReactUtils.promiseResolver(promise, e)
             }
     }
 
     override fun openBatteryOptimizationSettings(promise: Promise) {
         Notifee.getInstance()
-            .openBatteryOptimizationSettings(getCurrentActivity()) { e, _ ->
+            .openBatteryOptimizationSettings(getReactApplicationContext().getCurrentActivity()) { e, _ ->
                 NotifeeReactUtils.promiseResolver(promise, e)
             }
     }
@@ -305,7 +305,7 @@ class NotifeeApiModule(reactContext: ReactApplicationContext) :
 
     override fun openPowerManagerSettings(promise: Promise) {
         Notifee.getInstance()
-            .openPowerManagerSettings(getCurrentActivity()) { e, _ ->
+            .openPowerManagerSettings(getReactApplicationContext().getCurrentActivity()) { e, _ ->
                 NotifeeReactUtils.promiseResolver(promise, e)
             }
     }

package/android/src/test/java/app/notifee/core/model/NotificationAndroidModelSmallIconFallbackTest.java

@@ -0,0 +1,74 @@
+package app.notifee.core.model;
+
+/*
+ * 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 org.junit.Assert.assertNull;
+
+import android.os.Bundle;
+import app.notifee.core.ContextHolder;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.RuntimeEnvironment;
+
+/**
+ * Unit coverage for {@link NotificationAndroidModel#getSmallIcon()}.
+ *
+ * <p>The method returns {@code null} when the smallIcon string cannot be resolved to a valid
+ * resource id. This is the trigger condition that {@link app.notifee.core.NotificationManager}
+ * translates into the launcher-icon fallback (upstream invertase/notifee#733).
+ *
+ * <p>The happy path (valid resource id returned) is covered end-to-end by smoke tests on real
+ * devices — unit-testing it here would require a real drawable registered against the test
+ * application package, which Robolectric does not stage by default.
+ */
+@RunWith(RobolectricTestRunner.class)
+public class NotificationAndroidModelSmallIconFallbackTest {
+
+  @Before
+  public void setUp() {
+    // getSmallIcon() -> ResourceUtils.getImageResourceId() -> getResourceIdByName() reads
+    // ContextHolder.getApplicationContext() to call context.getResources().getIdentifier(...).
+    // Robolectric does not auto-populate ContextHolder, so we wire it up here. Same pattern
+    // used by ForegroundServiceTest and NotifeeAlarmManagerHandleStaleTest.
+    ContextHolder.setApplicationContext(RuntimeEnvironment.getApplication());
+  }
+
+  @Test
+  public void returnsNull_whenSmallIconKeyMissing() {
+    Bundle bundle = new Bundle();
+    NotificationAndroidModel model = NotificationAndroidModel.fromBundle(bundle);
+    assertNull(model.getSmallIcon());
+  }
+
+  @Test
+  public void returnsNull_whenSmallIconCannotBeResolved() {
+    Bundle bundle = new Bundle();
+    bundle.putString("smallIcon", "nonexistent_icon_name_for_test");
+    NotificationAndroidModel model = NotificationAndroidModel.fromBundle(bundle);
+    assertNull(model.getSmallIcon());
+  }
+
+  @Test
+  public void returnsNull_whenSmallIconEmptyString() {
+    Bundle bundle = new Bundle();
+    bundle.putString("smallIcon", "");
+    NotificationAndroidModel model = NotificationAndroidModel.fromBundle(bundle);
+    assertNull(model.getSmallIcon());
+  }
+}