react-native-notify-kit 10.5.0 → 10.7.0

package/README.md

@@ -148,6 +148,8 @@ useEffect(() => {
 
 > **Android event reliability:** Registering `onForegroundEvent()` initializes the native event relay. Pending events received while the `ReactContext` is unavailable are buffered. If the context becomes unavailable after a flush takes its buffer snapshot, undelivered events are requeued so a later native event relay flush can deliver them without duplication in the validated recovery path, while preserving FIFO, the 10-event capacity, and drop-oldest behavior. No application code changes or warm-up calls such as `getDisplayedNotifications()` are required; continue registering foreground and background handlers at the recommended points shown above. This hardens the Android event path investigated in [react-native-notify-kit#47](https://github.com/marcocrupi/react-native-notify-kit/issues/47) and relates to the event reliability and buffering problem tracked in [invertase/notifee#1279](https://github.com/invertase/notifee/issues/1279); the scenarios are not necessarily identical.
 
+<!-- Keep these callouts separate. -->
+
 > **Which handler fires when (iOS):**
 >
 > - Tap a notification while the app is **active in foreground** → `onForegroundEvent` receives `PRESS`.
@@ -156,6 +158,42 @@ useEffect(() => {
 >
 > Register **both** handlers if you need to react to taps in every app state. Resolves the confusion reported in upstream [invertase/notifee#1155](https://github.com/invertase/notifee/issues/1155).
 
+### Android notification numbers and launcher badges
+
+For notifications displayed through `notifee.displayNotification()`, use `android.badgeCount` to associate a number with
+an individual Android notification:
+
+```ts
+await notifee.createChannel({
+  id: 'messages',
+  name: 'Messages',
+  badge: true,
+});
+
+await notifee.displayNotification({
+  id: 'messages',
+  title: 'New messages',
+  body: 'You have 5 unread messages',
+  android: {
+    channelId: 'messages',
+    badgeCount: 5,
+  },
+});
+```
+
+`android.badgeCount` belongs to that notification and maps conceptually to AndroidX
+`NotificationCompat.Builder.setNumber(...)`. Display the notification again with the same `id` and a new `badgeCount`
+to update or replace it. The notification number itself is not limited to API level 26.
+
+On Android 8.0 (API level 26) and above, `badge: true` allows notifications in the channel to contribute to launcher
+badging; it does not set a count. Launcher and OEM behavior determines whether a number, only a notification dot, or a
+different aggregation is shown, so a numeric badge on the app icon is not guaranteed.
+
+Unlike the global iOS `notifee.setBadgeCount()` API, Android has no equivalent standard public API independent of posted
+notifications. `badgeCount: 0` neither cancels the posted notification nor provides a portable way to clear a global
+Android badge. See [Android Appearance: Badges](https://docs.page/marcocrupi/react-native-notify-kit/react-native/android/appearance#badges)
+for complete details.
+
 ## Notifee FCM Mode (NEW in 10.0.0, Expo CNG in 10.4.0)
 
 **Use `react-native-notify-kit` as the sole FCM display layer on both Android and iOS**: one developer API, no duplicate notifications on Android, no silent-push drops on iOS. Ship a server SDK payload, let the client handle it in one line, and set up the iOS Notification Service Extension with the Expo config plugin or, for bare React Native, the `init-nse` CLI. On Android, FCM Mode remains data-only: RNFirebase receives the message and calls `notifee.handleFcmMessage`.
@@ -204,6 +242,54 @@ export default {
 
 On Android, FCM Mode stays data-only. Configure Firebase and RNFirebase in the app, create the Android channel used by your payloads, then call `notifee.handleFcmMessage(remoteMessage)` from RNFirebase `onMessage` and `setBackgroundMessageHandler`. The Expo smoke app validates foreground and background delivery with the `android-expo-smoke` scenario on a real device.
 
+#### Android notification small icons
+
+For Expo CNG/prebuild projects, the config plugin can generate small notification icon resources without manually editing generated `android/` directories. This resource-generation option is independent of FCM Mode:
+
+```ts
+export default {
+  expo: {
+    plugins: [
+      [
+        'react-native-notify-kit',
+        {
+          android: {
+            icons: [
+              {
+                name: 'notification_message',
+                path: './assets/notification-message.png',
+                type: 'small',
+              },
+              {
+                name: 'notification_warning',
+                path: './assets/notification-warning.png',
+                type: 'small',
+              },
+            ],
+          },
+        },
+      ],
+    ],
+  },
+};
+```
+
+During prebuild, each entry generates density-specific PNG drawable resources (`mdpi` 24×24, `hdpi` 36×36, `xhdpi` 48×48, `xxhdpi` 72×72, and `xxxhdpi` 96×96) with a transparent background and `cover` resizing. The source `path` must be a project-relative PNG inside the project root. The `name` must start with a lowercase letter and contain only `a-z`, `0-9`, and `_`; invalid names are rejected rather than normalized. The array supports multiple icons and preserves their order. Each entry must include `type: 'small'`; omitting it or using another type fails during configuration/prebuild. The plugin also writes an Android resource-shrinker keep rule for the generated icons.
+
+`android.icons` generates resources; it does not select an icon for a notification. Pass the configured resource `name`—not its file path—to `android.smallIcon`:
+
+```ts
+await notifee.displayNotification({
+  title: 'New message',
+  android: {
+    channelId: 'messages',
+    smallIcon: 'notification_message',
+  },
+});
+```
+
+This option does not configure Firebase or set `com.google.firebase.messaging.default_notification_icon`.
+
 Android foreground service manifest configuration is also available through the NotifyKit config plugin, but it is explicit opt-in:
 
 ```ts
@@ -503,7 +589,7 @@ This fork fixes the following bugs that were never resolved in the original Noti
 >
 > **Reserved keys filtered from `data`** (custom payload keys matching these are dropped): prefixes `android.`, `google.`, `gcm.`, `fcm.` (with trailing dot — `fcmRegion`, `googleish` survive), `notifee` (no trailing dot — library's reserved namespace, `notifeeFoo` is also filtered), plus exact keys `from`, `collapse_key`, `message_type`, `message_id`, `aps`, `fcm_options`. The `fcm_options` exact-match matches iOS behavior on the Firebase analytics-label key. **Cross-platform note**: bare-`fcm` keys other than `fcm_options` (e.g. `fcmRegion`, `fcmToken`) are preserved on Android but filtered on iOS — rename server-side if you need strict parity.
 
-<!-- markdownlint-disable-line MD028 -->
+<!-- Keep these callouts separate. -->
 
 > **Note for policy-eligible apps requiring exact alarm APIs (alarm clocks, timers, calendars):**
 > Add `<uses-permission android:name="android.permission.USE_EXACT_ALARM" />` to your app's
@@ -800,6 +886,24 @@ await notifee.displayNotification({
 
 ## New APIs
 
+### Full-Screen Intent availability (Android)
+
+Use `getNotificationSettings()` to check whether the app currently has access to use Full-Screen Intents:
+
+```typescript
+import notifee, { AndroidNotificationSetting } from 'react-native-notify-kit';
+
+const settings = await notifee.getNotificationSettings();
+
+if (settings.android.fullScreenIntent === AndroidNotificationSetting.DISABLED) {
+  // Full-Screen Intent access is currently unavailable.
+}
+```
+
+`AndroidNotificationSetting.ENABLED` reports Full-Screen Intent access; it does not guarantee that a particular
+notification will be presented full-screen. See [Android Behaviour: Full-screen](https://docs.page/marcocrupi/react-native-notify-kit/react-native/android/behaviour#full-screen)
+for the full requirements and presentation behavior.
+
 ### `setNotificationConfig` (iOS)
 
 Controls whether Notifee intercepts remote (push) notification tap events on iOS.
@@ -870,6 +974,8 @@ Three causes account for the vast majority of reports:
 
 **Naming mismatch.** Android resource names are case-sensitive and only accept `[a-z0-9_]`. A string like `smallIcon: 'icNotification'` will not resolve `ic_notification.png`. Rename the `smallIcon` value to match the file on disk exactly.
 
+For Expo CNG/prebuild apps, use the NotifyKit config plugin's `android.icons` option instead of editing generated `android/` directories. It generates the density-specific drawables and writes a resource-shrinker keep rule during prebuild; continue to pass the configured resource `name` to `android.smallIcon`.
+
 For the full procedure on creating a small-icon asset via Android Studio, see [docs/react-native/android/appearance.mdx](docs/react-native/android/appearance.mdx).
 
 #### Custom sounds for push notifications in background or killed state

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

@@ -36,6 +36,7 @@ import app.notifee.core.model.ChannelGroupModel;
 import app.notifee.core.model.ChannelModel;
 import app.notifee.core.model.NotificationModel;
 import app.notifee.core.utility.AlarmUtils;
+import app.notifee.core.utility.FullScreenIntentUtils;
 import app.notifee.core.utility.PowerManagerUtils;
 import com.google.common.util.concurrent.FutureCallback;
 import com.google.common.util.concurrent.Futures;
@@ -508,6 +509,14 @@ public class Notifee {
       androidSettingsBundle.putInt("alarm", 0);
     }
 
+    boolean canUseFullScreenIntent = FullScreenIntentUtils.canUseFullScreenIntent();
+
+    if (canUseFullScreenIntent) {
+      androidSettingsBundle.putInt("fullScreenIntent", 1);
+    } else {
+      androidSettingsBundle.putInt("fullScreenIntent", 0);
+    }
+
     notificationSettingsBundle.putBundle("android", androidSettingsBundle);
     result.onComplete(null, notificationSettingsBundle);
   }

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

@@ -26,6 +26,7 @@ import android.app.PendingIntent;
 import android.app.Service;
 import android.content.Context;
 import android.content.Intent;
+import android.net.Uri;
 import android.os.Build;
 import android.os.Bundle;
 import android.os.IBinder;
@@ -39,14 +40,16 @@ import app.notifee.core.model.NotificationAndroidModel;
 import app.notifee.core.model.NotificationAndroidPressActionModel;
 import app.notifee.core.model.NotificationModel;
 import app.notifee.core.utility.IntentUtils;
-import java.util.concurrent.atomic.AtomicInteger;
 
 public class ReceiverService extends Service {
   private static final String TAG = "ReceiverService";
   public static final String REMOTE_INPUT_RECEIVER_KEY =
       "app.notifee.core.ReceiverService.REMOTE_INPUT_RECEIVER_KEY";
 
-  private static final AtomicInteger uniqueIds = new AtomicInteger(0);
+  private static final int PENDING_INTENT_REQUEST_CODE = 0;
+  private static final String PENDING_INTENT_URI_SCHEME = "notifee";
+  private static final String PENDING_INTENT_URI_AUTHORITY = "receiver-service";
+  private static final String PENDING_INTENT_URI_PATH = "pending-intent";
 
   static final String DELETE_INTENT = "app.notifee.core.ReceiverService.DELETE_INTENT";
   static final String PRESS_INTENT = "app.notifee.core.ReceiverService.PRESS_INTENT";
@@ -76,9 +79,43 @@ public class ReceiverService extends Service {
       }
     }
 
-    int uniqueInt = uniqueIds.getAndIncrement();
+    intent.setData(createPendingIntentData(intent));
+
     return PendingIntent.getService(
-        context, uniqueInt, intent, PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_MUTABLE);
+        context,
+        PENDING_INTENT_REQUEST_CODE,
+        intent,
+        PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_MUTABLE);
+  }
+
+  private static Uri createPendingIntentData(Intent intent) {
+    Bundle notification = intent.getBundleExtra("notification");
+    Bundle android = notification == null ? null : notification.getBundle("android");
+    Bundle pressAction = intent.getBundleExtra("pressAction");
+
+    String notificationId = notification == null ? null : notification.getString("id");
+    String notificationTag = android == null ? null : android.getString("tag");
+    String pressActionId = pressAction == null ? null : pressAction.getString("id");
+
+    Uri.Builder builder =
+        new Uri.Builder()
+            .scheme(PENDING_INTENT_URI_SCHEME)
+            .authority(PENDING_INTENT_URI_AUTHORITY)
+            .appendPath(PENDING_INTENT_URI_PATH);
+
+    appendNullableIdentityValue(builder, "interactionType", intent.getAction());
+    appendNullableIdentityValue(builder, "notificationTag", notificationTag);
+    appendNullableIdentityValue(builder, "notificationId", notificationId);
+    appendNullableIdentityValue(builder, "pressActionId", pressActionId);
+    return builder.build();
+  }
+
+  private static void appendNullableIdentityValue(
+      Uri.Builder builder, String name, @Nullable String value) {
+    builder.appendQueryParameter(name + "Present", value == null ? "0" : "1");
+    if (value != null) {
+      builder.appendQueryParameter(name, value);
+    }
   }
 
   @Nullable

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

@@ -34,6 +34,7 @@ import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.ListeningExecutorService;
 import java.util.ArrayList;
 import java.util.Objects;
+import java.util.concurrent.ExecutionException;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 
@@ -50,6 +51,31 @@ public class NotificationAndroidStyleModel {
     return new NotificationAndroidStyleModel(styleBundle);
   }
 
+  /** Builds a person from everything in its bundle except the remotely fetched icon. */
+  private static Person.Builder getPersonBuilder(Bundle personBundle) {
+    Person.Builder personBuilder = new Person.Builder();
+
+    personBuilder.setName(personBundle.getString("name"));
+
+    if (personBundle.containsKey("id")) {
+      personBuilder.setKey(personBundle.getString("id"));
+    }
+
+    if (personBundle.containsKey("bot")) {
+      personBuilder.setBot(personBundle.getBoolean("bot"));
+    }
+
+    if (personBundle.containsKey("important")) {
+      personBuilder.setImportant(personBundle.getBoolean("important"));
+    }
+
+    if (personBundle.containsKey("uri")) {
+      personBuilder.setUri(personBundle.getString("uri"));
+    }
+
+    return personBuilder;
+  }
+
   /**
    * Converts a person bundle from JS into a Person
    *
@@ -60,54 +86,59 @@ public class NotificationAndroidStyleModel {
       ListeningExecutorService lExecutor, Bundle personBundle) {
     return lExecutor.submit(
         () -> {
-          Person.Builder personBuilder = new Person.Builder();
-
-          personBuilder.setName(personBundle.getString("name"));
-
-          if (personBundle.containsKey("id")) {
-            personBuilder.setKey(personBundle.getString("id"));
-          }
-
-          if (personBundle.containsKey("bot")) {
-            personBuilder.setBot(personBundle.getBoolean("bot"));
-          }
-
-          if (personBundle.containsKey("important")) {
-            personBuilder.setImportant(personBundle.getBoolean("important"));
-          }
+          Person.Builder personBuilder = getPersonBuilder(personBundle);
 
           if (personBundle.containsKey("icon")) {
             String personIcon = Objects.requireNonNull(personBundle.getString("icon"));
-            Bitmap personIconBitmap = null;
 
             try {
-              personIconBitmap =
+              Bitmap personIconBitmap =
                   ResourceUtils.getImageBitmapFromUrl(personIcon).get(10, TimeUnit.SECONDS);
+
+              if (personIconBitmap != null) {
+                personBuilder.setIcon(IconCompat.createWithAdaptiveBitmap(personIconBitmap));
+              }
             } catch (TimeoutException e) {
               Logger.e(
                   TAG,
                   "Timeout occurred whilst trying to retrieve a person icon: " + personIcon,
                   e);
-            } catch (Exception e) {
+            } catch (ExecutionException | RuntimeException e) {
               Logger.e(
                   TAG,
-                  "An error occurred whilst trying to retrieve a person icon: " + personIcon,
+                  "An error occurred whilst trying to retrieve or create a person icon: "
+                      + personIcon,
                   e);
             }
-
-            if (personIconBitmap != null) {
-              personBuilder.setIcon(IconCompat.createWithAdaptiveBitmap(personIconBitmap));
-            }
-          }
-
-          if (personBundle.containsKey("uri")) {
-            personBuilder.setUri(personBundle.getString("uri"));
           }
 
           return personBuilder.build();
         });
   }
 
+  /**
+   * Awaits a person, degrading to an icon-less one only if the outer deadline expires.
+   *
+   * <p>The icon lookup has a shorter timeout, but scheduling delays, process suspension, or other
+   * task stalls can still exhaust this outer deadline. The runtime cause is not inferred here.
+   *
+   * <p>ExecutionException and InterruptedException propagate because neither proves that only the
+   * icon failed.
+   */
+  private static Person awaitPerson(ListenableFuture<Person> personTask, Bundle personBundle)
+      throws InterruptedException, ExecutionException {
+    try {
+      return personTask.get(20, TimeUnit.SECONDS);
+    } catch (TimeoutException e) {
+      Logger.e(TAG, "Timeout occurred whilst trying to retrieve a messaging style person", e);
+    } catch (ExecutionException e) {
+      Logger.e(TAG, "Unexpected failure whilst building a messaging style person", e);
+      throw e;
+    }
+
+    return getPersonBuilder(personBundle).build();
+  }
+
   public Bundle toBundle() {
     return (Bundle) mNotificationAndroidStyleBundle.clone();
   }
@@ -291,11 +322,9 @@ public class NotificationAndroidStyleModel {
       ListeningExecutorService lExecutor) {
     return lExecutor.submit(
         () -> {
-          Person person =
-              getPerson(
-                      lExecutor,
-                      Objects.requireNonNull(mNotificationAndroidStyleBundle.getBundle("person")))
-                  .get(20, TimeUnit.SECONDS);
+          Bundle personBundle =
+              Objects.requireNonNull(mNotificationAndroidStyleBundle.getBundle("person"));
+          Person person = awaitPerson(getPerson(lExecutor, personBundle), personBundle);
 
           NotificationCompat.MessagingStyle messagingStyle =
               new NotificationCompat.MessagingStyle(person);
@@ -322,9 +351,9 @@ public class NotificationAndroidStyleModel {
             long timestamp = BundleValueReader.getLongPreserving(message, "timestamp");
 
             if (message.containsKey("person")) {
+              Bundle messagePersonBundle = Objects.requireNonNull(message.getBundle("person"));
               messagePerson =
-                  getPerson(lExecutor, Objects.requireNonNull(message.getBundle("person")))
-                      .get(20, TimeUnit.SECONDS);
+                  awaitPerson(getPerson(lExecutor, messagePersonBundle), messagePersonBundle);
             }
 
             messagingStyle =

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

@@ -0,0 +1,53 @@
+package app.notifee.core.utility;
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import static app.notifee.core.ContextHolder.getApplicationContext;
+
+import android.content.Context;
+import androidx.annotation.Nullable;
+import androidx.annotation.VisibleForTesting;
+import androidx.core.app.NotificationManagerCompat;
+
+public class FullScreenIntentUtils {
+
+  /**
+   * Whether the app currently has the Android access required to use full-screen intents.
+   *
+   * <p>API levels below 29 do not use the full-screen intent permission model. API levels 29
+   * through 33 require {@code USE_FULL_SCREEN_INTENT}. API level 34 and above use Android's
+   * full-screen intent special app access.
+   *
+   * @return true when the required access is currently available. This does not guarantee that a
+   *     particular notification will be presented full-screen.
+   */
+  public static boolean canUseFullScreenIntent() {
+    return canUseFullScreenIntent(getApplicationContext());
+  }
+
+  @VisibleForTesting
+  static boolean canUseFullScreenIntent(@Nullable Context context) {
+    // The application context is expected to exist on the public path. Preserve the existing
+    // defensive fail-open behavior for an internal state that cannot prove access is denied.
+    if (context == null) {
+      return true;
+    }
+
+    return NotificationManagerCompat.from(context).canUseFullScreenIntent();
+  }
+}

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

@@ -170,7 +170,21 @@ public class ResourceUtils {
         new BaseBitmapDataSubscriber() {
           @Override
           protected void onNewResultImpl(@Nullable Bitmap bitmap) {
-            bitmapTCS.set(bitmap);
+            // Fresco owns this pooled bitmap and only guarantees it is valid for the
+            // duration of this callback. If it escapes without a copy, Fresco may
+            // recycle it on memory-cache eviction (e.g. onTrimMemory) while the
+            // notification is still being built, posted or re-parceled, crashing with
+            // "Can't copy/parcel a recycled bitmap" or "Canvas: trying to use a
+            // recycled bitmap".
+            if (bitmap == null) {
+              bitmapTCS.set(null);
+              return;
+            }
+            Bitmap.Config config = bitmap.getConfig();
+            if (config == null) {
+              config = Bitmap.Config.ARGB_8888;
+            }
+            bitmapTCS.set(bitmap.copy(config, false));
           }
 
           @Override