react-native-notify-kit 10.2.0 → 10.3.0

package/README.md

@@ -421,11 +421,11 @@ As bugs are fixed, this table is updated. See [CHANGELOG.md](CHANGELOG.md) for f
 
 Some upstream Notifee issues are not bugs in the library itself but platform-level limitations imposed by Android's Doze mode and vendor power management — no library code can make `AlarmManager` deliver an alarm to, or a foreground service survive inside, an app the OEM has explicitly paused. For these, the fork provides **documented mitigations**: user-facing helper APIs, code-level self-healing where possible, and decision guides that steer consumers toward the Android primitive most resilient to the specific vendor policy.
 
-| Upstream issue                                                           | Symptom                                                                                                                                                                                                                                                                                                                                                                                | Platform root cause                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | Fork mitigation                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
-| ------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| [invertase/notifee#410](https://github.com/invertase/notifee/issues/410) | Foreground service paused on screen lock (Samsung OneUI, ~6 seconds after screen off on battery) and killed immediately when the app is backgrounded (Xiaomi MIUI)                                                                                                                                                                                                                     | Vendor aggressive battery-saver and autostart policies suspend or terminate foreground services of apps not whitelisted in the OEM's protected-apps / autostart settings. Partially Doze-related on non-exempt `foregroundServiceType` values; mostly OEM-specific behavior catalogued at [dontkillmyapp.com](https://dontkillmyapp.com/).                                                                                                                                                                                                                                                                                                            | **(1) Decision guide** — the [Timers: foreground service or `SET_ALARM_CLOCK`?](#timers-foreground-service-or-set_alarm_clock) section recommends the `SET_ALARM_CLOCK` trigger over a silent foreground service for rest, cooking, and recovery timer use cases. `setAlarmClock` is the same primitive the stock Clock app uses and is generally respected by vendor aggressive-kill policies. **(2) Foreground service use case matrix** — the [Foreground service use case guide](#foreground-service-use-case-guide) documents which `foregroundServiceType` values are Doze-CPU-exempt, which have type-specific timeouts, and the Google Play policy constraints that rule out misusing `mediaPlayback` for silent timers. **(3) `openPowerManagerSettings()` helper API** — deep-links the user to the correct vendor autostart / protected-apps screen on 16 manufacturers; whitelisting the app prevents both `BOOT_COMPLETED` suppression and background FGS kills. |
-| [invertase/notifee#734](https://github.com/invertase/notifee/issues/734) | Scheduled trigger notifications silently lost across a device reboot on OEM devices (Xiaomi MIUI, OnePlus, Huawei EMUI, Oppo ColorOS, Vivo FuntouchOS)                                                                                                                                                                                                                                 | The vendor OS suppresses the `BOOT_COMPLETED` broadcast to apps the user has not manually whitelisted, so the library's `RebootBroadcastReceiver` never runs and persisted `AlarmManager` triggers are never re-armed after reboot.                                                                                                                                                                                                                                                                                                                                                                                                                   | **(1) `BOOT_COUNT` cold-start self-heal (code)** — on every app init, `InitProvider` compares `Settings.Global.BOOT_COUNT` against the last-known value in `SharedPreferences` and re-arms every persisted trigger on a background thread if a boot delta is detected, even when `BOOT_COMPLETED` was never delivered. Paired with a process-wide `AtomicBoolean` race guard in `NotifeeAlarmManager.rescheduleNotifications` that prevents double-advancement when the reboot receiver and the cold-start path race. **(2) `openPowerManagerSettings()` helper API** — the same vendor-settings deep-link used by #410, pointing the user at the autostart whitelist for defense in depth.                                                                                                                                                                                                                                                                                   |
-| [invertase/notifee#927](https://github.com/invertase/notifee/issues/927) | Custom sound passed via `displayNotification({ android: { sound, channelId }, ios: { sound } })` is ignored for **remote push notifications** (FCM/APNs) delivered while the app is in background or killed — the system default sound plays instead. Foreground delivery and **locally-scheduled notifications** (`displayNotification`, `createTriggerNotification`) are unaffected. | When a remote push arrives while the app is killed, the JavaScript layer never runs — the system tray item is drawn by the OS (Android system + Firebase SDK; iOS + APNs) before any Notifee code executes. On Android API 26+, the `NotificationChannel` sound is set once at channel creation and is immutable thereafter — `NotificationCompat.Builder.setSound()` is silently ignored when the builder has a `channelId`. On iOS, the Notification Service Extension only rewrites incoming push content when the payload contains a `notifee_options` key (see `NotifeeCoreExtensionHelper.m:43`); a plain APNs payload is delivered unmodified. | **Documentation only — the platform contract cannot be worked around at the library layer.** Recipes by platform: **(Android)** create the `NotificationChannel` with the desired sound at first-run (the channel sound is immutable; to change it the channel must be deleted and recreated under a new `channelId`), and configure `AndroidNotification.sound` in the FCM payload server-side so the system tray honors it for background pushes. As a heavier alternative, switch the backend to an FCM data-only payload and call `displayNotification()` from a headless task — the JS-side `android.sound` is then honored, but this trades simplicity for the cost of running JS on every push. **(iOS)** either set `aps.sound` directly in the APNs payload, or install the Notification Service Extension (see `docs/react-native/ios/remote-notification-support.mdx`) and ship the sound under `notifee_options.ios.sound` in the push payload.                   |
+| Upstream issue                                                           | Symptom                                                                                                                                                                                                                                                                                                                                                                                | Platform root cause                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | Fork mitigation                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
+| ------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| [invertase/notifee#410](https://github.com/invertase/notifee/issues/410) | Foreground service paused on screen lock (Samsung OneUI, ~6 seconds after screen off on battery) and killed immediately when the app is backgrounded (Xiaomi MIUI)                                                                                                                                                                                                                     | Vendor aggressive battery-saver and autostart policies suspend or terminate foreground services of apps not whitelisted in the OEM's protected-apps / autostart settings. Partially Doze-related on non-exempt `foregroundServiceType` values; mostly OEM-specific behavior catalogued at [dontkillmyapp.com](https://dontkillmyapp.com/).                                                                                                                                                                                                                                                                                                            | **(1) Decision guide** — the [Timers: foreground service or `SET_ALARM_CLOCK`?](#timers-foreground-service-or-set_alarm_clock) section recommends the `SET_ALARM_CLOCK` trigger over a silent foreground service for rest, cooking, and recovery timer use cases. `setAlarmClock` is the same primitive the stock Clock app uses and is generally respected by vendor aggressive-kill policies. **(2) Foreground service use case matrix** — the [Foreground service use case guide](#foreground-service-use-case-guide) documents which `foregroundServiceType` values are Doze-CPU-exempt, which have type-specific timeouts, and the Google Play policy constraints that rule out misusing `mediaPlayback` for silent timers. **(3) `openPowerManagerSettings()` helper API** — points users toward known vendor autostart / protected-apps screen candidates when available; these links are best-effort because firmware variants may move, block, or remove those settings activities. |
+| [invertase/notifee#734](https://github.com/invertase/notifee/issues/734) | Scheduled trigger notifications silently lost across a device reboot on OEM devices (Xiaomi MIUI, OnePlus, Huawei EMUI, Oppo ColorOS, Vivo FuntouchOS)                                                                                                                                                                                                                                 | The vendor OS suppresses the `BOOT_COMPLETED` broadcast to apps the user has not manually whitelisted, so the library's `RebootBroadcastReceiver` never runs and persisted `AlarmManager` triggers are never re-armed after reboot.                                                                                                                                                                                                                                                                                                                                                                                                                   | **(1) `BOOT_COUNT` cold-start self-heal (code)** — on every app init, `InitProvider` compares `Settings.Global.BOOT_COUNT` against the last-known value in `SharedPreferences` and re-arms every persisted trigger on a background thread if a boot delta is detected, even when `BOOT_COMPLETED` was never delivered. Paired with a process-wide `AtomicBoolean` race guard in `NotifeeAlarmManager.rescheduleNotifications` that prevents double-advancement when the reboot receiver and the cold-start path race. **(2) `openPowerManagerSettings()` helper API** — the same vendor-settings deep-link used by #410, pointing the user at the autostart whitelist for defense in depth.                                                                                                                                                                                                                                                                                                  |
+| [invertase/notifee#927](https://github.com/invertase/notifee/issues/927) | Custom sound passed via `displayNotification({ android: { sound, channelId }, ios: { sound } })` is ignored for **remote push notifications** (FCM/APNs) delivered while the app is in background or killed — the system default sound plays instead. Foreground delivery and **locally-scheduled notifications** (`displayNotification`, `createTriggerNotification`) are unaffected. | When a remote push arrives while the app is killed, the JavaScript layer never runs — the system tray item is drawn by the OS (Android system + Firebase SDK; iOS + APNs) before any Notifee code executes. On Android API 26+, the `NotificationChannel` sound is set once at channel creation and is immutable thereafter — `NotificationCompat.Builder.setSound()` is silently ignored when the builder has a `channelId`. On iOS, the Notification Service Extension only rewrites incoming push content when the payload contains a `notifee_options` key (see `NotifeeCoreExtensionHelper.m:43`); a plain APNs payload is delivered unmodified. | **Documentation only — the platform contract cannot be worked around at the library layer.** Recipes by platform: **(Android)** create the `NotificationChannel` with the desired sound at first-run (the channel sound is immutable; to change it the channel must be deleted and recreated under a new `channelId`), and configure `AndroidNotification.sound` in the FCM payload server-side so the system tray honors it for background pushes. As a heavier alternative, switch the backend to an FCM data-only payload and call `displayNotification()` from a headless task — the JS-side `android.sound` is then honored, but this trades simplicity for the cost of running JS on every push. **(iOS)** either set `aps.sound` directly in the APNs payload, or install the Notification Service Extension (see `docs/react-native/ios/remote-notification-support.mdx`) and ship the sound under `notifee_options.ios.sound` in the push payload.                                  |
 
 Both mitigations are intentionally additive to the existing reboot-recovery and foreground-service code paths and do not replace the consumer's responsibility to prompt the user for battery-optimization exemption when the use case warrants it. For a complete vendor-by-vendor reference of autostart, battery-saver, and background-restriction behavior, see [dontkillmyapp.com](https://dontkillmyapp.com/).
 
@@ -526,7 +526,7 @@ The fork mitigates this with two layers that work together:
 
 **1. Automatic cold-start recovery.** On every app init, the library compares `Settings.Global.BOOT_COUNT` against the value recorded on the previous run. If a reboot has occurred since the last run — whether or not `BOOT_COMPLETED` was delivered to your app — the library re-arms every persisted trigger on a background thread. This means that on an OEM device where `BOOT_COMPLETED` was suppressed, simply opening your app (or having it cold-started by any other entry point: push notification, geofence, share intent) recovers all missed and upcoming alarms. Previously, opening the app alone did not recover them. This recovery runs unconditionally — it is not gated by the `notifee_init_warmup_enabled` metadata flag, because it is a correctness fix rather than a startup optimization.
 
-**2. Vendor settings helper APIs.** The existing `getPowerManagerInfo()` and `openPowerManagerSettings()` APIs let your app guide the user directly to the correct vendor settings screen (Xiaomi Autostart, Huawei Protected Apps, Oppo Startup Manager, and 13 more vendors) to whitelist the app. Once whitelisted, `BOOT_COMPLETED` is delivered normally on every reboot and exact alarm timing is preserved without waiting for the next app cold-start. The same whitelist also prevents the OS from killing your foreground service when the app is backgrounded — so this helper is the primary mitigation path for **both** trigger-notification reliability and foreground-service reliability on OEM devices.
+**2. Vendor settings helper APIs.** The existing `getPowerManagerInfo()` and `openPowerManagerSettings()` APIs let your app guide the user toward known vendor settings candidates (Xiaomi Autostart, Huawei Protected Apps, Oppo Startup Manager, and 13 more vendors) to whitelist the app. These candidates are opened best-effort: Android may reject or fail to resolve a vendor-specific settings activity on some firmware variants, and the helper fails safely instead of crashing. Consumer apps do not need to inherit package-visibility `<queries>` declarations for these helpers, and the helper does not use the direct `ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS` request path. Whitelisting the app in vendor settings can restore normal reboot delivery and reduce background foreground-service kills on affected devices, but this remains subject to OEM firmware and user/device policy — so this helper is a mitigation path for **both** trigger-notification reliability and foreground-service reliability on OEM devices.
 
 A typical integration that combines both layers looks like this:
 

package/android/src/main/AndroidManifest.xml

@@ -8,7 +8,6 @@
   <uses-permission android:name="android.permission.INTERNET" />
   <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
   <uses-permission android:name="android.permission.SCHEDULE_EXACT_ALARM" />
-  <uses-permission android:name="android.permission.BROADCAST_CLOSE_SYSTEM_DIALOGS" android:maxSdkVersion="30" />
   <!-- For Xiaomi devices to enable heads-up notifications as default (https://github.com/invertase/notifee/issues/296) -->
   <uses-permission android:name="android.permission.ACCESS_NOTIFICATION_POLICY" android:minSdkVersion="23" />
 

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

@@ -39,6 +39,7 @@ import app.notifee.core.event.ForegroundServiceEvent;
 import app.notifee.core.event.NotificationEvent;
 import app.notifee.core.interfaces.MethodCallResult;
 import app.notifee.core.model.NotificationModel;
+import app.notifee.core.utility.ParcelableCompatReader;
 
 public class ForegroundService extends Service {
   private static final String TAG = "ForegroundService";
@@ -186,7 +187,8 @@ public class ForegroundService extends Service {
       if (extras != null) {
         // Hash code is sent to service to ensure it is kept the same
         int hashCode = extras.getInt("hashCode");
-        Notification notification = extras.getParcelable("notification");
+        Notification notification =
+            ParcelableCompatReader.getParcelable(extras, "notification", Notification.class);
         Bundle bundle = extras.getBundle("notificationBundle");
 
         if (notification != null && bundle != null) {

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

@@ -37,6 +37,7 @@ import app.notifee.core.model.NotificationAndroidModel;
 import app.notifee.core.model.NotificationModel;
 import app.notifee.core.model.TimestampTriggerModel;
 import app.notifee.core.utility.AlarmUtils;
+import app.notifee.core.utility.BundleValueReader;
 import app.notifee.core.utility.ExtendedListenableFuture;
 import app.notifee.core.utility.ObjectUtils;
 import com.google.common.util.concurrent.FutureCallback;
@@ -195,7 +196,8 @@ class NotifeeAlarmManager {
                   NotificationManager.displayNotification(notificationModel, triggerBundle),
                   voidDisplayedNotification -> {
                     if (triggerBundle.containsKey("repeatFrequency")
-                        && ObjectUtils.getInt(triggerBundle.get("repeatFrequency")) != -1) {
+                        && BundleValueReader.getIntPreserving(triggerBundle, "repeatFrequency")
+                            != -1) {
                       TimestampTriggerModel trigger =
                           TimestampTriggerModel.fromBundle(triggerBundle);
                       // scheduleTimestampTriggerNotification() calls setNextTimestamp()
@@ -424,7 +426,7 @@ class NotifeeAlarmManager {
     NotificationModel notificationModel =
         NotificationModel.fromBundle(ObjectUtils.bytesToBundle(notificationBytes));
 
-    int triggerType = ObjectUtils.getInt(triggerBundle.get("type"));
+    int triggerType = BundleValueReader.getIntPreserving(triggerBundle, "type");
 
     switch (triggerType) {
       case 0:

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

@@ -23,10 +23,12 @@ import static app.notifee.core.event.NotificationEvent.TYPE_ACTION_PRESS;
 import static app.notifee.core.event.NotificationEvent.TYPE_PRESS;
 import static java.lang.Integer.parseInt;
 
+import android.Manifest;
 import android.app.Notification;
 import android.app.PendingIntent;
 import android.content.Context;
 import android.content.Intent;
+import android.content.pm.PackageManager;
 import android.graphics.Bitmap;
 import android.net.Uri;
 import android.os.Build;
@@ -59,6 +61,7 @@ import app.notifee.core.model.NotificationAndroidPressActionModel;
 import app.notifee.core.model.NotificationAndroidStyleModel;
 import app.notifee.core.model.NotificationModel;
 import app.notifee.core.model.TimestampTriggerModel;
+import app.notifee.core.utility.BundleValueReader;
 import app.notifee.core.utility.ExtendedListenableFuture;
 import app.notifee.core.utility.IntentUtils;
 import app.notifee.core.utility.ObjectUtils;
@@ -166,18 +169,7 @@ class NotificationManager {
             //      so tapping the notification opens the app (defense-in-depth for paths that
             //      bypass the TS validator).
             //   2. pressAction has the opt-out sentinel id: user explicitly passed
-            //      pressAction: null in JS — pass null to createIntent so no launch intent
-            //      is created (non-tappable notification).
-            //   3. pressAction is a normal bundle: pass through unchanged.
-            // Resolve the effective pressAction bundle for the content intent.
-            // Three cases:
-            //   1. pressAction is null (absent from bundle, e.g. trigger rehydrated from Room DB
-            //      after app kill): synthesize default { id:'default', launchActivity:'default' }
-            //      so tapping the notification opens the app (defense-in-depth for paths that
-            //      bypass the TS validator).
-            //   2. pressAction has the opt-out sentinel id: user explicitly passed
-            //      pressAction: null in JS — pass null to createIntent so no launch intent
-            //      is created (non-tappable notification).
+            //      pressAction: null in JS, so no content intent is created.
             //   3. pressAction is a normal bundle: pass through unchanged.
             //
             // pressActionForIntent  → used for creating the launch intent (or null for opt-out)
@@ -203,23 +195,25 @@ class NotificationManager {
 
             int targetSdkVersion =
                 ContextHolder.getApplicationContext().getApplicationInfo().targetSdkVersion;
-            if (targetSdkVersion >= Build.VERSION_CODES.S
-                && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-              builder.setContentIntent(
-                  NotificationPendingIntent.createIntent(
-                      notificationModel.getHashCode(),
-                      pressActionForIntent,
-                      TYPE_PRESS,
-                      new String[] {"notification", "pressAction"},
-                      notificationModel.toBundle(),
-                      pressActionForExtras));
-            } else {
-              builder.setContentIntent(
-                  ReceiverService.createIntent(
-                      ReceiverService.PRESS_INTENT,
-                      new String[] {"notification", "pressAction"},
-                      notificationModel.toBundle(),
-                      pressActionForIntent));
+            if (pressActionForIntent != null) {
+              if (targetSdkVersion >= Build.VERSION_CODES.S
+                  && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+                builder.setContentIntent(
+                    NotificationPendingIntent.createIntent(
+                        notificationModel.getHashCode(),
+                        pressActionForIntent,
+                        TYPE_PRESS,
+                        new String[] {"notification", "pressAction"},
+                        notificationModel.toBundle(),
+                        pressActionForExtras));
+              } else {
+                builder.setContentIntent(
+                    ReceiverService.createIntent(
+                        ReceiverService.PRESS_INTENT,
+                        new String[] {"notification", "pressAction"},
+                        notificationModel.toBundle(),
+                        pressActionForIntent));
+              }
             }
 
             if (notificationModel.getTitle() != null) {
@@ -248,9 +242,7 @@ class NotificationManager {
 
             builder.setColorized(androidModel.getColorized());
 
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
-              builder.setChronometerCountDown(androidModel.getChronometerCountDown());
-            }
+            builder.setChronometerCountDown(androidModel.getChronometerCountDown());
 
             if (androidModel.getGroup() != null) {
               builder.setGroup(androidModel.getGroup());
@@ -716,7 +708,18 @@ class NotificationManager {
                     Trace.endSection();
                   }
                 } else {
-                  NotificationManagerCompat.from(getApplicationContext())
+                  Context context = getApplicationContext();
+                  if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU
+                      && context.checkSelfPermission(Manifest.permission.POST_NOTIFICATIONS)
+                          != PackageManager.PERMISSION_GRANTED) {
+                    String message =
+                        "POST_NOTIFICATIONS permission is not granted. Notification was not"
+                            + " displayed.";
+                    Logger.w(TAG, message);
+                    return Futures.immediateFailedFuture(new SecurityException(message));
+                  }
+
+                  NotificationManagerCompat.from(context)
                       .notify(androidBundle.getTag(), hashCode, notification);
                 }
 
@@ -733,7 +736,7 @@ class NotificationManager {
 
   static ListenableFuture<Void> createTriggerNotification(
       NotificationModel notificationModel, Bundle triggerBundle) {
-    int triggerType = ObjectUtils.getInt(triggerBundle.get("type"));
+    int triggerType = BundleValueReader.getIntPreserving(triggerBundle, "type");
     ListenableFuture<Void> scheduleFuture;
     switch (triggerType) {
       case 0:
@@ -873,10 +876,6 @@ class NotificationManager {
         () -> {
           List<Bundle> notifications = new ArrayList<Bundle>();
 
-          if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
-            return notifications;
-          }
-
           android.app.NotificationManager notificationManager =
               (android.app.NotificationManager)
                   getApplicationContext().getSystemService(Context.NOTIFICATION_SERVICE);
@@ -896,19 +895,19 @@ class NotificationManager {
               notificationBundle = new Bundle();
               notificationBundle.putString("id", "" + sbNotification.getId());
 
-              Object title = extras.get(Notification.EXTRA_TITLE);
+              Object title = BundleValueReader.getValue(extras, Notification.EXTRA_TITLE);
 
               if (title != null) {
                 notificationBundle.putString("title", title.toString());
               }
 
-              Object text = extras.get(Notification.EXTRA_TEXT);
+              Object text = BundleValueReader.getValue(extras, Notification.EXTRA_TEXT);
 
               if (text != null) {
                 notificationBundle.putString("body", text.toString());
               }
 
-              Object subtitle = extras.get(Notification.EXTRA_SUB_TEXT);
+              Object subtitle = BundleValueReader.getValue(extras, Notification.EXTRA_SUB_TEXT);
 
               if (subtitle != null) {
                 notificationBundle.putString("subtitle", subtitle.toString());
@@ -927,7 +926,8 @@ class NotificationManager {
 
               displayNotificationBundle.putString("id", "" + sbNotification.getId());
             } else {
-              displayNotificationBundle.putString("id", "" + notificationBundle.get("id"));
+              displayNotificationBundle.putString(
+                  "id", String.valueOf(BundleValueReader.getValue(notificationBundle, "id")));
             }
 
             if (triggerBundle != null) {
@@ -972,7 +972,7 @@ class NotificationManager {
       if (!shouldIncludeInData(key)) {
         continue;
       }
-      Object value = extras.get(key);
+      Object value = BundleValueReader.getValue(extras, key);
       if (value != null) {
         dataBundle.putString(key, value.toString());
       }

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

@@ -21,6 +21,7 @@ import static app.notifee.core.event.NotificationEvent.TYPE_ACTION_PRESS;
 import static app.notifee.core.event.NotificationEvent.TYPE_DISMISSED;
 import static app.notifee.core.event.NotificationEvent.TYPE_PRESS;
 
+import android.annotation.SuppressLint;
 import android.app.PendingIntent;
 import android.app.Service;
 import android.content.Context;
@@ -171,10 +172,6 @@ public class ReceiverService extends Service {
     }
   }
 
-  // ACTION_CLOSE_SYSTEM_DIALOGS is deprecated since API 31, but is still needed on API < 31
-  // to close the notification drawer after an action press. Already guarded with Build.VERSION
-  // check.
-  @SuppressWarnings("deprecation")
   private void onActionPressIntent(Intent intent) {
     Bundle notification = intent.getBundleExtra("notification");
     Bundle pressAction = intent.getBundleExtra("pressAction");
@@ -221,16 +218,24 @@ public class ReceiverService extends Service {
           mainComponent,
           pressActionBundle.getLaunchActivityFlags());
 
-      int targetSdkVersion =
-          ContextHolder.getApplicationContext().getApplicationInfo().targetSdkVersion;
+      closeSystemDialogsBestEffort();
+    }
+  }
 
-      // Close notification drawer if application SDK is Android 11 and lower
-      // See
-      // https://developer.android.com/about/versions/12/behavior-changes-all#close-system-dialogs
-      if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) {
-        ContextHolder.getApplicationContext()
-            .sendBroadcast(new Intent(Intent.ACTION_CLOSE_SYSTEM_DIALOGS));
-      }
+  @SuppressWarnings("deprecation")
+  @SuppressLint("MissingPermission")
+  private void closeSystemDialogsBestEffort() {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+      return;
+    }
+
+    // BROADCAST_CLOSE_SYSTEM_DIALOGS is protected/system-only, so the library intentionally does
+    // not declare it. Keep this pre-Android 12 legacy broadcast best-effort; Android 12+ skips it.
+    try {
+      ContextHolder.getApplicationContext()
+          .sendBroadcast(new Intent(Intent.ACTION_CLOSE_SYSTEM_DIALOGS));
+    } catch (SecurityException e) {
+      Logger.w(TAG, "Unable to close system dialogs with legacy broadcast", e);
     }
   }
 

package/android/src/main/java/app/notifee/core/database/NotifeeCoreDatabase.java

@@ -43,10 +43,7 @@ public abstract class NotifeeCoreDatabase extends RoomDatabase {
   static final ListeningExecutorService databaseWriteListeningExecutor =
       MoreExecutors.listeningDecorator(databaseWriteExecutor);
 
-  /**
-   * Migrate from: version 1 to version 2 - where the {@link WorkDataEntity} has an extra field:
-   * alert
-   */
+  /** Migrate from version 1 to version 2 by adding the with_alarm_manager column. */
   @VisibleForTesting
   static final Migration MIGRATION_1_2 =
       new Migration(1, 2) {

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

@@ -23,7 +23,7 @@ import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.core.app.NotificationCompat;
 import androidx.core.app.NotificationManagerCompat;
-import app.notifee.core.utility.ObjectUtils;
+import app.notifee.core.utility.BundleValueReader;
 import java.util.ArrayList;
 import java.util.Objects;
 
@@ -72,11 +72,8 @@ public class ChannelModel {
   }
 
   public Integer getImportance() {
-    if (mChannelBundle.containsKey("importance")) {
-      return ObjectUtils.getInt(mChannelBundle.get("importance"));
-    }
-
-    return NotificationManagerCompat.IMPORTANCE_DEFAULT;
+    return BundleValueReader.getIntPreserving(
+        mChannelBundle, "importance", NotificationManagerCompat.IMPORTANCE_DEFAULT);
   }
 
   public @Nullable Integer getLightColor() {
@@ -88,14 +85,11 @@ public class ChannelModel {
   }
 
   public int getVisibility() {
-    if (mChannelBundle.containsKey("visibility")) {
-      return ObjectUtils.getInt(mChannelBundle.get("visibility"));
-    }
-
-    return NotificationCompat.VISIBILITY_PRIVATE;
+    return BundleValueReader.getIntPreserving(
+        mChannelBundle, "visibility", NotificationCompat.VISIBILITY_PRIVATE);
   }
 
-  // Bundle.getParcelableArrayList returns ArrayList<?>, so the (Integer) cast is inherently
+  // BundleValueReader.getArrayListValue returns ArrayList<?>, so the (Integer) cast is inherently
   // unchecked but correct for our serialization format.
   @SuppressWarnings("unchecked")
   public long[] getVibrationPattern() {
@@ -104,7 +98,8 @@ public class ChannelModel {
     }
 
     ArrayList<?> vibrationPattern =
-        Objects.requireNonNull(mChannelBundle.getParcelableArrayList("vibrationPattern"));
+        Objects.requireNonNull(
+            BundleValueReader.getArrayListValue(mChannelBundle, "vibrationPattern"));
 
     long[] vibrateArray = new long[vibrationPattern.size()];
 

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

@@ -20,7 +20,7 @@ package app.notifee.core.model;
 import android.os.Bundle;
 import androidx.annotation.NonNull;
 import app.notifee.core.Logger;
-import app.notifee.core.utility.ObjectUtils;
+import app.notifee.core.utility.BundleValueReader;
 import java.util.concurrent.TimeUnit;
 
 public class IntervalTriggerModel {
@@ -54,10 +54,6 @@ public class IntervalTriggerModel {
   }
 
   public int getInterval() {
-    if (mIntervalTriggerBundle.containsKey("interval")) {
-      return ObjectUtils.getInt(mIntervalTriggerBundle.get("interval"));
-    }
-
-    return -1;
+    return BundleValueReader.getIntPreserving(mIntervalTriggerBundle, "interval", -1);
   }
 }

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

@@ -77,8 +77,7 @@ public class NotificationAndroidActionModel {
    * @return RemoteInput
    */
   public @Nullable RemoteInput getRemoteInput(NotificationCompat.Action.Builder actionBuilder) {
-    if (mNotificationAndroidActionBundle.containsKey("input")
-        && android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.KITKAT_WATCH) {
+    if (mNotificationAndroidActionBundle.containsKey("input")) {
       Bundle inputBundle =
           Objects.requireNonNull(mNotificationAndroidActionBundle.getBundle("input"));
 

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

@@ -29,7 +29,9 @@ import androidx.annotation.RequiresApi;
 import androidx.core.app.NotificationCompat;
 import androidx.core.app.NotificationManagerCompat;
 import app.notifee.core.Logger;
+import app.notifee.core.utility.BundleValueReader;
 import app.notifee.core.utility.ObjectUtils;
+import app.notifee.core.utility.ParcelableCompatReader;
 import app.notifee.core.utility.ResourceUtils;
 import java.util.ArrayList;
 import java.util.Objects;
@@ -50,7 +52,9 @@ public class NotificationAndroidModel {
   public @Nullable ArrayList<NotificationAndroidActionModel> getActions() {
     if (mNotificationAndroidBundle.containsKey("actions")) {
       ArrayList<Bundle> actionBundles =
-          Objects.requireNonNull(mNotificationAndroidBundle.getParcelableArrayList("actions"));
+          Objects.requireNonNull(
+              ParcelableCompatReader.getParcelableArrayList(
+                  mNotificationAndroidBundle, "actions", Bundle.class));
       ArrayList<NotificationAndroidActionModel> actions = new ArrayList<>(actionBundles.size());
 
       for (Bundle actionBundle : actionBundles) {
@@ -72,7 +76,8 @@ public class NotificationAndroidModel {
 
     ArrayList<?> foregroundServiceTypesArrayList =
         Objects.requireNonNull(
-            mNotificationAndroidBundle.getParcelableArrayList("foregroundServiceTypes"));
+            BundleValueReader.getArrayListValue(
+                mNotificationAndroidBundle, "foregroundServiceTypes"));
 
     if (foregroundServiceTypesArrayList.isEmpty()) {
       Logger.w(TAG, "foregroundServiceTypes is empty; treating as absent");
@@ -137,12 +142,8 @@ public class NotificationAndroidModel {
    * @return Integer
    */
   public @Nullable Integer getBadgeIconType() {
-    if (mNotificationAndroidBundle.containsKey("badgeIconType")) {
-
-      return ObjectUtils.getInt(mNotificationAndroidBundle.get("badgeIconType"));
-    }
-
-    return NotificationCompat.BADGE_ICON_LARGE;
+    return BundleValueReader.getIntPreserving(
+        mNotificationAndroidBundle, "badgeIconType", NotificationCompat.BADGE_ICON_LARGE);
   }
 
   /**
@@ -266,11 +267,8 @@ public class NotificationAndroidModel {
    * @return int
    */
   public int getGroupAlertBehaviour() {
-    if (mNotificationAndroidBundle.containsKey("groupAlertBehavior")) {
-      return ObjectUtils.getInt(mNotificationAndroidBundle.get("groupAlertBehavior"));
-    }
-
-    return NotificationCompat.GROUP_ALERT_ALL;
+    return BundleValueReader.getIntPreserving(
+        mNotificationAndroidBundle, "groupAlertBehavior", NotificationCompat.GROUP_ALERT_ALL);
   }
 
   /**
@@ -327,14 +325,15 @@ public class NotificationAndroidModel {
    *
    * @return ArrayList<Integer>
    */
-  // Bundle.getParcelableArrayList returns ArrayList<?>, so element casts to String/Integer
+  // BundleValueReader.getArrayListValue returns ArrayList<?>, so element casts to String/Integer
   // are inherently unchecked but correct for our serialization format.
   @SuppressWarnings("unchecked")
   public @Nullable ArrayList<Integer> getLights() {
     if (mNotificationAndroidBundle.containsKey("lights")) {
       try {
         ArrayList<?> lightList =
-            Objects.requireNonNull(mNotificationAndroidBundle.getParcelableArrayList("lights"));
+            Objects.requireNonNull(
+                BundleValueReader.getArrayListValue(mNotificationAndroidBundle, "lights"));
         String rawColor = (String) lightList.get(0);
 
         ArrayList<Integer> lights = new ArrayList<>(3);
@@ -368,7 +367,7 @@ public class NotificationAndroidModel {
    */
   public Integer getNumber() {
     if (mNotificationAndroidBundle.containsKey("badgeCount")) {
-      return ObjectUtils.getInt(mNotificationAndroidBundle.get("badgeCount"));
+      return BundleValueReader.getIntPreserving(mNotificationAndroidBundle, "badgeCount");
     }
 
     return null;
@@ -403,7 +402,8 @@ public class NotificationAndroidModel {
     }
 
     ArrayList<?> flagsArrayList =
-        Objects.requireNonNull(mNotificationAndroidBundle.getParcelableArrayList("flags"));
+        Objects.requireNonNull(
+            BundleValueReader.getArrayListValue(mNotificationAndroidBundle, "flags"));
 
     int[] flagsArray = new int[flagsArrayList.size()];
 
@@ -469,7 +469,11 @@ public class NotificationAndroidModel {
       return NotificationCompat.PRIORITY_DEFAULT;
     }
 
-    int importance = ObjectUtils.getInt(mNotificationAndroidBundle.get("importance"));
+    int importance =
+        BundleValueReader.getIntPreserving(
+            mNotificationAndroidBundle,
+            "importance",
+            NotificationManagerCompat.IMPORTANCE_DEFAULT);
     switch (importance) {
       case NotificationManagerCompat.IMPORTANCE_HIGH:
         return NotificationCompat.PRIORITY_HIGH;
@@ -494,8 +498,8 @@ public class NotificationAndroidModel {
           Objects.requireNonNull(mNotificationAndroidBundle.getBundle("progress"));
 
       return new AndroidProgress(
-          ObjectUtils.getInt(progressBundle.get("max")),
-          ObjectUtils.getInt(progressBundle.get("current")),
+          BundleValueReader.getIntPreserving(progressBundle, "max"),
+          BundleValueReader.getIntPreserving(progressBundle, "current"),
           progressBundle.getBoolean("indeterminate", false));
     }
 
@@ -607,7 +611,7 @@ public class NotificationAndroidModel {
    */
   public @Nullable Long getTimeoutAfter() {
     if (mNotificationAndroidBundle.containsKey("timeoutAfter")) {
-      return ObjectUtils.getLong(mNotificationAndroidBundle.get("timeoutAfter"));
+      return BundleValueReader.getLongPreserving(mNotificationAndroidBundle, "timeoutAfter");
     }
 
     return null;
@@ -635,7 +639,7 @@ public class NotificationAndroidModel {
    *
    * @return long[]
    */
-  // Bundle.getParcelableArrayList returns ArrayList<?>, so the (Integer) cast is inherently
+  // BundleValueReader.getArrayListValue returns ArrayList<?>, so the (Integer) cast is inherently
   // unchecked but correct for our serialization format.
   @SuppressWarnings("unchecked")
   public long[] getVibrationPattern() {
@@ -645,7 +649,7 @@ public class NotificationAndroidModel {
 
     ArrayList<?> vibrationPattern =
         Objects.requireNonNull(
-            mNotificationAndroidBundle.getParcelableArrayList("vibrationPattern"));
+            BundleValueReader.getArrayListValue(mNotificationAndroidBundle, "vibrationPattern"));
 
     long[] vibrateArray = new long[vibrationPattern.size()];
 
@@ -663,11 +667,8 @@ public class NotificationAndroidModel {
    * @return int
    */
   public int getVisibility() {
-    if (mNotificationAndroidBundle.containsKey("visibility")) {
-      return ObjectUtils.getInt(mNotificationAndroidBundle.get("visibility"));
-    }
-
-    return NotificationCompat.VISIBILITY_PRIVATE;
+    return BundleValueReader.getIntPreserving(
+        mNotificationAndroidBundle, "visibility", NotificationCompat.VISIBILITY_PRIVATE);
   }
 
   /**
@@ -676,11 +677,7 @@ public class NotificationAndroidModel {
    * @return long
    */
   public long getTimestamp() {
-    if (mNotificationAndroidBundle.containsKey("timestamp")) {
-      return ObjectUtils.getLong(mNotificationAndroidBundle.get("timestamp"));
-    }
-
-    return -1;
+    return BundleValueReader.getLongPreserving(mNotificationAndroidBundle, "timestamp", -1L);
   }
 
   public static class AndroidProgress {