react-native-notify-kit 10.2.1 → 10.3.0

package/android/src/test/java/app/notifee/core/utility/ParcelableCompatReaderTest.java

@@ -0,0 +1,124 @@
+package app.notifee.core.utility;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertThrows;
+
+import android.app.Notification;
+import android.os.Bundle;
+import java.util.ArrayList;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.RuntimeEnvironment;
+import org.robolectric.annotation.Config;
+
+@RunWith(RobolectricTestRunner.class)
+public class ParcelableCompatReaderTest {
+
+  @Test
+  @Config(sdk = 32)
+  public void getParcelable_legacyPath_returnsNotificationAndNullWhenMissing() {
+    Bundle bundle = new Bundle();
+    Notification notification = createNotification();
+    bundle.putParcelable("notification", notification);
+    bundle.putParcelable("explicitNull", (Notification) null);
+
+    assertEquals(
+        notification,
+        ParcelableCompatReader.getParcelable(bundle, "notification", Notification.class));
+    assertNull(ParcelableCompatReader.getParcelable(bundle, "missing", Notification.class));
+    assertNull(ParcelableCompatReader.getParcelable(bundle, "explicitNull", Notification.class));
+  }
+
+  @Test
+  @Config(sdk = 33)
+  public void getParcelable_typedPath_returnsNotificationAndNullWhenMissing() {
+    Bundle bundle = new Bundle();
+    Notification notification = createNotification();
+    bundle.putParcelable("notification", notification);
+    bundle.putParcelable("explicitNull", (Notification) null);
+
+    assertEquals(
+        notification,
+        ParcelableCompatReader.getParcelable(bundle, "notification", Notification.class));
+    assertNull(ParcelableCompatReader.getParcelable(bundle, "missing", Notification.class));
+    assertNull(ParcelableCompatReader.getParcelable(bundle, "explicitNull", Notification.class));
+  }
+
+  @Test
+  @Config(sdk = 32)
+  public void getParcelable_legacyPath_preservesWrongClassCast() {
+    Bundle bundle = new Bundle();
+    bundle.putParcelable("notification", createNotification());
+
+    assertThrows(
+        ClassCastException.class,
+        () -> {
+          Bundle ignored =
+              ParcelableCompatReader.getParcelable(bundle, "notification", Bundle.class);
+        });
+  }
+
+  @Test
+  @Config(sdk = 33)
+  public void getParcelable_typedPath_returnsNullForWrongClass() {
+    Bundle bundle = new Bundle();
+    bundle.putParcelable("notification", createNotification());
+
+    assertNull(ParcelableCompatReader.getParcelable(bundle, "notification", Bundle.class));
+  }
+
+  @Test
+  @Config(sdk = 32)
+  public void getParcelableArrayList_legacyPath_returnsBundleList() {
+    Bundle bundle = new Bundle();
+    ArrayList<Bundle> bundles = createBundleList();
+    bundle.putParcelableArrayList("bundles", bundles);
+    bundle.putParcelableArrayList("explicitNull", null);
+
+    ArrayList<Bundle> result =
+        ParcelableCompatReader.getParcelableArrayList(bundle, "bundles", Bundle.class);
+
+    assertNotNull(result);
+    assertEquals(1, result.size());
+    assertEquals("first", result.get(0).getString("name"));
+    assertNull(ParcelableCompatReader.getParcelableArrayList(bundle, "missing", Bundle.class));
+    assertNull(ParcelableCompatReader.getParcelableArrayList(bundle, "explicitNull", Bundle.class));
+  }
+
+  @Test
+  @Config(sdk = 33)
+  public void getParcelableArrayList_typedPath_returnsBundleList() {
+    Bundle bundle = new Bundle();
+    ArrayList<Bundle> bundles = createBundleList();
+    bundle.putParcelableArrayList("bundles", bundles);
+    bundle.putParcelableArrayList("explicitNull", null);
+
+    ArrayList<Bundle> result =
+        ParcelableCompatReader.getParcelableArrayList(bundle, "bundles", Bundle.class);
+
+    assertNotNull(result);
+    assertEquals(1, result.size());
+    assertEquals("first", result.get(0).getString("name"));
+    assertNull(ParcelableCompatReader.getParcelableArrayList(bundle, "missing", Bundle.class));
+    assertNull(ParcelableCompatReader.getParcelableArrayList(bundle, "explicitNull", Bundle.class));
+  }
+
+  private static Notification createNotification() {
+    return new Notification.Builder(RuntimeEnvironment.getApplication(), "reader-test")
+        .setSmallIcon(android.R.drawable.ic_dialog_info)
+        .setContentTitle("reader-test")
+        .build();
+  }
+
+  private static ArrayList<Bundle> createBundleList() {
+    Bundle nested = new Bundle();
+    nested.putString("name", "first");
+
+    ArrayList<Bundle> bundles = new ArrayList<>();
+    bundles.add(nested);
+    return bundles;
+  }
+}

package/android/src/test/java/io/invertase/notifee/HeadlessTaskReactHostTest.java

@@ -0,0 +1,136 @@
+package io.invertase.notifee;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.same;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import android.app.Application;
+import android.os.Looper;
+import app.notifee.core.ContextHolder;
+import com.facebook.react.ReactInstanceEventListener;
+import com.facebook.react.bridge.JavaOnlyMap;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.common.LifecycleState;
+import com.facebook.react.modules.appregistry.AppRegistry;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.robolectric.RuntimeEnvironment;
+import org.robolectric.Shadows;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.annotation.Config;
+import org.robolectric.annotation.LooperMode;
+
+@RunWith(RobolectricTestRunner.class)
+@Config(application = HeadlessTaskReactHostTest.TestApplication.class, sdk = 34)
+@LooperMode(LooperMode.Mode.PAUSED)
+public class HeadlessTaskReactHostTest {
+
+  private TestApplication application;
+
+  @Before
+  public void setUp() {
+    application = (TestApplication) RuntimeEnvironment.getApplication();
+    application.reactHost.reset();
+    ContextHolder.setApplicationContext(application);
+    Shadows.shadowOf(Looper.getMainLooper()).idle();
+  }
+
+  @Test
+  public void startTask_whenReactContextInitializes_drainsQueuedTaskAfterCurrentDelay() {
+    JavaOnlyMap params = new JavaOnlyMap();
+    params.putString("source", "react-host-test");
+
+    HeadlessTask headlessTask = new HeadlessTask();
+    HeadlessTask.TaskConfig taskConfig =
+        new HeadlessTask.TaskConfig("test-headless-task", 60000L, params, null);
+    ReactContext reactContext = mock(ReactContext.class);
+    AppRegistry appRegistry = mock(AppRegistry.class);
+    when(reactContext.getLifecycleState()).thenReturn(LifecycleState.BEFORE_RESUME);
+    when(reactContext.hasActiveReactInstance()).thenReturn(true);
+    when(reactContext.getJSModule(AppRegistry.class)).thenReturn(appRegistry);
+
+    WritableMap copiedParams = taskConfig.getTaskConfig().getData();
+
+    headlessTask.startTask(application, taskConfig);
+
+    assertEquals(
+        "ReactHost should be started through reflection", 1, application.reactHost.startCalls);
+    assertEquals(
+        "ReactContext listener should be registered through reflection",
+        1,
+        application.reactHost.listeners.size());
+    verify(appRegistry, never())
+        .startHeadlessTask(anyInt(), any(String.class), any(WritableMap.class));
+
+    ReactInstanceEventListener listener = application.reactHost.listeners.get(0);
+    listener.onReactContextInitialized(reactContext);
+
+    assertEquals(
+        "ReactContext listener should be removed after initialization",
+        0,
+        application.reactHost.listeners.size());
+    Shadows.shadowOf(Looper.getMainLooper()).idleFor(499, java.util.concurrent.TimeUnit.MILLISECONDS);
+    verify(appRegistry, never()).startHeadlessTask(anyInt(), any(String.class), any(WritableMap.class));
+
+    Shadows.shadowOf(Looper.getMainLooper()).idleFor(1, java.util.concurrent.TimeUnit.MILLISECONDS);
+
+    ArgumentCaptor<Integer> taskIdCaptor = ArgumentCaptor.forClass(Integer.class);
+    verify(appRegistry)
+        .startHeadlessTask(
+            taskIdCaptor.capture(), eq("test-headless-task"), same(copiedParams));
+    assertEquals(taskIdCaptor.getValue().intValue(), taskConfig.getReactTaskId());
+    assertEquals(
+        "source payload should be copied into the queued task",
+        "react-host-test",
+        copiedParams.getString("source"));
+    assertEquals(
+        "copied params should receive the native task id",
+        taskConfig.getTaskId(),
+        copiedParams.getInt("taskId"));
+  }
+
+  public static class TestApplication extends Application {
+    final TestReactHost reactHost = new TestReactHost();
+
+    public TestReactHost getReactHost() {
+      return reactHost;
+    }
+  }
+
+  public static class TestReactHost {
+    int startCalls;
+    final List<ReactInstanceEventListener> listeners = new ArrayList<>();
+
+    public ReactContext getCurrentReactContext() {
+      return null;
+    }
+
+    public void addReactInstanceEventListener(ReactInstanceEventListener listener) {
+      listeners.add(listener);
+    }
+
+    public void removeReactInstanceEventListener(ReactInstanceEventListener listener) {
+      listeners.remove(listener);
+    }
+
+    public void start() {
+      startCalls++;
+    }
+
+    void reset() {
+      startCalls = 0;
+      listeners.clear();
+    }
+  }
+}

package/android/src/test/java/io/invertase/notifee/NotifeeEventSubscriberRoutingTest.java

@@ -0,0 +1,262 @@
+package io.invertase.notifee;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertSame;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockStatic;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import android.app.Application;
+import android.os.Bundle;
+import android.os.Looper;
+import androidx.lifecycle.ProcessLifecycleOwner;
+import app.notifee.core.ContextHolder;
+import app.notifee.core.event.NotificationEvent;
+import app.notifee.core.model.NotificationModel;
+import com.facebook.react.ReactInstanceEventListener;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicBoolean;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.MockedStatic;
+import org.robolectric.RuntimeEnvironment;
+import org.robolectric.Shadows;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.annotation.Config;
+
+@RunWith(RobolectricTestRunner.class)
+@Config(application = NotifeeEventSubscriberRoutingTest.TestApplication.class, sdk = 34)
+public class NotifeeEventSubscriberRoutingTest {
+
+  private TestApplication application;
+  private HeadlessTask headlessTask;
+
+  @Before
+  public void setUp() throws Exception {
+    application = (TestApplication) RuntimeEnvironment.getApplication();
+    application.reactHost.reset();
+    ContextHolder.setApplicationContext(application);
+    headlessTask = NotifeeReactUtils.INSTANCE.getHeadlessTaskManager();
+    resetHeadlessTask(headlessTask);
+    moveProcessToBackground();
+    Shadows.shadowOf(Looper.getMainLooper()).idle();
+  }
+
+  @After
+  public void tearDown() throws Exception {
+    moveProcessToBackground();
+    resetHeadlessTask(headlessTask);
+    application.reactHost.reset();
+  }
+
+  @Test
+  public void onNotificationEvent_typePressWhenResumed_routesToForegroundEvent() throws Exception {
+    moveProcessToForeground();
+    DeviceEventManagerModule.RCTDeviceEventEmitter emitter =
+        mock(DeviceEventManagerModule.RCTDeviceEventEmitter.class);
+    ReactContext reactContext = mock(ReactContext.class);
+    when(reactContext.hasActiveReactInstance()).thenReturn(true);
+    when(reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class))
+        .thenReturn(emitter);
+    application.reactHost.currentReactContext = reactContext;
+
+    WritableMap eventMap = mock(WritableMap.class);
+    WritableMap detailMap = mock(WritableMap.class);
+    WritableMap notificationMap = mock(WritableMap.class);
+    WritableMap pressActionMap = mock(WritableMap.class);
+
+    try (MockedStatic<Arguments> arguments = mockArguments(
+        eventMap, detailMap, notificationMap, pressActionMap)) {
+      new NotifeeEventSubscriber().onNotificationEvent(buildPressEvent("routing-foreground"));
+    }
+
+    verify(eventMap).putInt("type", NotificationEvent.TYPE_PRESS);
+    verify(detailMap).putMap("notification", notificationMap);
+    verify(detailMap).putMap("pressAction", pressActionMap);
+    verify(detailMap).putString("input", "typed reply");
+    verify(eventMap).putMap("detail", detailMap);
+    verify(eventMap).putBoolean("headless", false);
+    verify(emitter).emit(NotifeeEventSubscriber.NOTIFICATION_EVENT_KEY, eventMap);
+    verify(eventMap, never()).copy();
+    assertEquals("foreground routing must not queue a headless task", 0, taskQueueSize());
+    assertEquals("foreground routing must not start ReactHost", 0, application.reactHost.startCalls);
+  }
+
+  @Test
+  public void onNotificationEvent_typePressWhenNotResumed_routesToHeadlessTask() throws Exception {
+    moveProcessToBackground();
+    DeviceEventManagerModule.RCTDeviceEventEmitter emitter =
+        mock(DeviceEventManagerModule.RCTDeviceEventEmitter.class);
+    ReactContext reactContext = mock(ReactContext.class);
+    when(reactContext.hasActiveReactInstance()).thenReturn(true);
+    when(reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class))
+        .thenReturn(emitter);
+    application.reactHost.currentReactContext = null;
+
+    WritableMap eventMap = mock(WritableMap.class);
+    WritableMap queuedEventMap = mock(WritableMap.class);
+    WritableMap detailMap = mock(WritableMap.class);
+    WritableMap notificationMap = mock(WritableMap.class);
+    WritableMap pressActionMap = mock(WritableMap.class);
+    when(eventMap.copy()).thenReturn(queuedEventMap);
+
+    try (MockedStatic<Arguments> arguments = mockArguments(
+        eventMap, detailMap, notificationMap, pressActionMap)) {
+      new NotifeeEventSubscriber().onNotificationEvent(buildPressEvent("routing-background"));
+    }
+
+    verify(eventMap).putInt("type", NotificationEvent.TYPE_PRESS);
+    verify(detailMap).putMap("notification", notificationMap);
+    verify(detailMap).putMap("pressAction", pressActionMap);
+    verify(detailMap).putString("input", "typed reply");
+    verify(eventMap).putMap("detail", detailMap);
+    verify(eventMap).putBoolean("headless", true);
+    verify(eventMap).copy();
+    verify(queuedEventMap).putInt("taskId", headlessTaskQueue().get(0).getTaskId());
+    verify(emitter, never()).emit(any(String.class), any(WritableMap.class));
+
+    assertEquals("background routing should queue exactly one headless task", 1, taskQueueSize());
+    HeadlessTask.TaskConfig queuedTask = headlessTaskQueue().get(0);
+    assertEquals(NotifeeEventSubscriber.NOTIFICATION_EVENT_KEY, queuedTask.getTaskConfig().getTaskKey());
+    assertEquals(60000L, queuedTask.getTaskConfig().getTimeout());
+    assertSame(queuedEventMap, queuedTask.getTaskConfig().getData());
+    assertEquals("background routing should initialize ReactHost via reflection", 1, application.reactHost.startCalls);
+    assertEquals("background routing should register one ReactContext listener", 1, application.reactHost.listeners.size());
+  }
+
+  private static MockedStatic<Arguments> mockArguments(
+      WritableMap eventMap,
+      WritableMap detailMap,
+      WritableMap notificationMap,
+      WritableMap pressActionMap) {
+    MockedStatic<Arguments> arguments = mockStatic(Arguments.class);
+    arguments.when(Arguments::createMap).thenReturn(eventMap, detailMap);
+    arguments.when(() -> Arguments.fromBundle(any(Bundle.class)))
+        .thenReturn(notificationMap, pressActionMap);
+    return arguments;
+  }
+
+  private static NotificationEvent buildPressEvent(String notificationId) {
+    Bundle notificationBundle = new Bundle();
+    notificationBundle.putString("id", notificationId);
+    notificationBundle.putString("title", "Routing test " + notificationId);
+    Bundle androidBundle = new Bundle();
+    androidBundle.putString("channelId", "routing-test-channel");
+    notificationBundle.putBundle("android", androidBundle);
+
+    Bundle pressActionBundle = new Bundle();
+    pressActionBundle.putString("id", "default");
+    pressActionBundle.putString("launchActivity", "default");
+
+    Bundle extras = new Bundle();
+    extras.putBundle("pressAction", pressActionBundle);
+    extras.putString("input", "typed reply");
+
+    return new NotificationEvent(
+        NotificationEvent.TYPE_PRESS, NotificationModel.fromBundle(notificationBundle), extras);
+  }
+
+  private static void moveProcessToForeground() {
+    ProcessLifecycleOwner owner = (ProcessLifecycleOwner) ProcessLifecycleOwner.get();
+    owner.activityStarted$lifecycle_process_release();
+    owner.activityResumed$lifecycle_process_release();
+  }
+
+  private static void moveProcessToBackground() throws Exception {
+    ProcessLifecycleOwner.init$lifecycle_process_release(RuntimeEnvironment.getApplication());
+    ProcessLifecycleOwner owner = (ProcessLifecycleOwner) ProcessLifecycleOwner.get();
+    int resumedCounter = getIntField(owner, "resumedCounter");
+    for (int i = 0; i < resumedCounter; i++) {
+      owner.activityPaused$lifecycle_process_release();
+    }
+    owner.dispatchPauseIfNeeded$lifecycle_process_release();
+
+    int startedCounter = getIntField(owner, "startedCounter");
+    for (int i = 0; i < startedCounter; i++) {
+      owner.activityStopped$lifecycle_process_release();
+    }
+    owner.dispatchStopIfNeeded$lifecycle_process_release();
+  }
+
+  private static int getIntField(Object target, String name) throws Exception {
+    Field field = target.getClass().getDeclaredField(name);
+    field.setAccessible(true);
+    return field.getInt(target);
+  }
+
+  private int taskQueueSize() throws Exception {
+    return headlessTaskQueue().size();
+  }
+
+  @SuppressWarnings("unchecked")
+  private List<HeadlessTask.TaskConfig> headlessTaskQueue() throws Exception {
+    Field queueField = HeadlessTask.class.getDeclaredField("mTaskQueue");
+    queueField.setAccessible(true);
+    return (List<HeadlessTask.TaskConfig>) queueField.get(headlessTask);
+  }
+
+  private static void resetHeadlessTask(HeadlessTask task) throws Exception {
+    Field queueField = HeadlessTask.class.getDeclaredField("mTaskQueue");
+    queueField.setAccessible(true);
+    ((List<?>) queueField.get(task)).clear();
+
+    setAtomicBoolean(task, "mIsReactContextInitialized", false);
+    setAtomicBoolean(task, "mWillDrainTaskQueue", false);
+    setAtomicBoolean(task, "mIsInitializingReactContext", false);
+    setAtomicBoolean(task, "mIsHeadlessJsTaskListenerRegistered", false);
+  }
+
+  private static void setAtomicBoolean(HeadlessTask task, String name, boolean value)
+      throws Exception {
+    Field field = HeadlessTask.class.getDeclaredField(name);
+    field.setAccessible(true);
+    ((AtomicBoolean) field.get(task)).set(value);
+  }
+
+  public static class TestApplication extends Application {
+    final TestReactHost reactHost = new TestReactHost();
+
+    public TestReactHost getReactHost() {
+      return reactHost;
+    }
+  }
+
+  public static class TestReactHost {
+    ReactContext currentReactContext;
+    int startCalls;
+    final List<ReactInstanceEventListener> listeners = new ArrayList<>();
+
+    public ReactContext getCurrentReactContext() {
+      return currentReactContext;
+    }
+
+    public void addReactInstanceEventListener(ReactInstanceEventListener listener) {
+      listeners.add(listener);
+    }
+
+    public void removeReactInstanceEventListener(ReactInstanceEventListener listener) {
+      listeners.remove(listener);
+    }
+
+    public void start() {
+      startCalls++;
+    }
+
+    void reset() {
+      currentReactContext = null;
+      startCalls = 0;
+      listeners.clear();
+    }
+  }
+}

package/android/src/test/java/io/invertase/notifee/NotifeeReactUtilsDrawerTest.java

@@ -0,0 +1,24 @@
+package io.invertase.notifee;
+
+import app.notifee.core.ContextHolder;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RuntimeEnvironment;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.annotation.Config;
+
+@RunWith(RobolectricTestRunner.class)
+@Config(sdk = 34)
+public class NotifeeReactUtilsDrawerTest {
+
+  @Before
+  public void setUp() {
+    ContextHolder.setApplicationContext(RuntimeEnvironment.getApplication());
+  }
+
+  @Test
+  public void hideNotificationDrawer_whenStatusBarReflectionFails_doesNotCrash() {
+    NotifeeReactUtils.INSTANCE.hideNotificationDrawer();
+  }
+}

package/dist/types/Notification.d.ts

@@ -320,9 +320,12 @@ export declare enum EventType {
      */
     DISMISSED = 0,
     /**
-     * Event type is sent when a notification has been pressed by the user.
+     * Event type is sent when the user presses a notification body and body tap is enabled.
      *
-     * On Android, notifications must include an `android.pressAction` property for this event to trigger.
+     * On Android, omitted `android.pressAction` defaults to opening the app and can emit this
+     * event. Setting `android.pressAction` to `null` disables the notification body tap and
+     * prevents `PRESS`/`getInitialNotification()` from that body tap. Action buttons emit
+     * `ACTION_PRESS` separately.
      *
      * On iOS, this event is always sent when the user presses a notification.
      */

package/dist/types/Notification.js

@@ -26,9 +26,12 @@ export var EventType;
      */
     EventType[EventType["DISMISSED"] = 0] = "DISMISSED";
     /**
-     * Event type is sent when a notification has been pressed by the user.
+     * Event type is sent when the user presses a notification body and body tap is enabled.
      *
-     * On Android, notifications must include an `android.pressAction` property for this event to trigger.
+     * On Android, omitted `android.pressAction` defaults to opening the app and can emit this
+     * event. Setting `android.pressAction` to `null` disables the notification body tap and
+     * prevents `PRESS`/`getInitialNotification()` from that body tap. Action buttons emit
+     * `ACTION_PRESS` separately.
      *
      * On iOS, this event is always sent when the user presses a notification.
      */

package/dist/types/Notification.js.map

@@ -1 +1 @@
-{"version":3,"file":"Notification.js","sourceRoot":"","sources":["../../src/types/Notification.ts"],"names":[],"mappings":"AAAA;;GAEG;AA4UH;;;;;GAKG;AACH,MAAM,CAAN,IAAY,SA2EX;AA3ED,WAAY,SAAS;IACnB;;;;;OAKG;IACH,gDAAY,CAAA;IAEZ;;;;;;;OAOG;IACH,mDAAa,CAAA;IAEb;;;;;;OAMG;IACH,2CAAS,CAAA;IAET;;OAEG;IACH,yDAAgB,CAAA;IAEhB;;;;;;OAMG;IACH,mDAAa,CAAA;IAEb;;;;;OAKG;IACH,uDAAe,CAAA;IAEf;;;;OAIG;IACH,+DAAmB,CAAA;IAEnB;;;;OAIG;IACH,2EAAyB,CAAA;IAEzB;;OAEG;IACH,yFAAgC,CAAA;IAEhC;;;;OAIG;IACH,iEAAoB,CAAA;AACtB,CAAC,EA3EW,SAAS,KAAT,SAAS,QA2EpB;AA+ED;;;;;;GAMG;AACH,MAAM,CAAN,IAAY,mBA0BX;AA1BD,WAAY,mBAAmB;IAC7B;;;;;;;OAOG;IACH,kFAAmB,CAAA;IAEnB;;OAEG;IACH,iEAAU,CAAA;IAEV;;OAEG;IACH,yEAAc,CAAA;IAEd;;;OAGG;IACH,2EAAe,CAAA;AACjB,CAAC,EA1BW,mBAAmB,KAAnB,mBAAmB,QA0B9B"}
+{"version":3,"file":"Notification.js","sourceRoot":"","sources":["../../src/types/Notification.ts"],"names":[],"mappings":"AAAA;;GAEG;AA4UH;;;;;GAKG;AACH,MAAM,CAAN,IAAY,SA8EX;AA9ED,WAAY,SAAS;IACnB;;;;;OAKG;IACH,gDAAY,CAAA;IAEZ;;;;;;;OAOG;IACH,mDAAa,CAAA;IAEb;;;;;;;;;OASG;IACH,2CAAS,CAAA;IAET;;OAEG;IACH,yDAAgB,CAAA;IAEhB;;;;;;OAMG;IACH,mDAAa,CAAA;IAEb;;;;;OAKG;IACH,uDAAe,CAAA;IAEf;;;;OAIG;IACH,+DAAmB,CAAA;IAEnB;;;;OAIG;IACH,2EAAyB,CAAA;IAEzB;;OAEG;IACH,yFAAgC,CAAA;IAEhC;;;;OAIG;IACH,iEAAoB,CAAA;AACtB,CAAC,EA9EW,SAAS,KAAT,SAAS,QA8EpB;AA+ED;;;;;;GAMG;AACH,MAAM,CAAN,IAAY,mBA0BX;AA1BD,WAAY,mBAAmB;IAC7B;;;;;;;OAOG;IACH,kFAAmB,CAAA;IAEnB;;OAEG;IACH,iEAAU,CAAA;IAEV;;OAEG;IACH,yEAAc,CAAA;IAEd;;;OAGG;IACH,2EAAe,CAAA;AACjB,CAAC,EA1BW,mBAAmB,KAAnB,mBAAmB,QA0B9B"}

package/dist/types/NotificationAndroid.d.ts

@@ -1266,6 +1266,10 @@ export declare enum AndroidLaunchActivityFlag {
      */
     LAUNCHED_FROM_HISTORY = 10,
     /**
+     * @deprecated Android deprecated `FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET` in API 21.
+     * Use `AndroidLaunchActivityFlag.NEW_DOCUMENT` for new code. This value remains
+     * supported for backward compatibility with existing apps and persisted payloads.
+     *
      * See [FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET](https://developer.android.com/reference/android/content/Intent.html#FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET) on the official Android documentation for more information.
      */
     CLEAR_WHEN_TASK_RESET = 11,

package/dist/types/NotificationAndroid.js

@@ -339,6 +339,10 @@ export var AndroidLaunchActivityFlag;
      */
     AndroidLaunchActivityFlag[AndroidLaunchActivityFlag["LAUNCHED_FROM_HISTORY"] = 10] = "LAUNCHED_FROM_HISTORY";
     /**
+     * @deprecated Android deprecated `FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET` in API 21.
+     * Use `AndroidLaunchActivityFlag.NEW_DOCUMENT` for new code. This value remains
+     * supported for backward compatibility with existing apps and persisted payloads.
+     *
      * See [FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET](https://developer.android.com/reference/android/content/Intent.html#FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET) on the official Android documentation for more information.
      */
     AndroidLaunchActivityFlag[AndroidLaunchActivityFlag["CLEAR_WHEN_TASK_RESET"] = 11] = "CLEAR_WHEN_TASK_RESET";

package/dist/types/NotificationAndroid.js.map

@@ -1 +1 @@
-{"version":3,"file":"NotificationAndroid.js","sourceRoot":"","sources":["../../src/types/NotificationAndroid.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"NotificationAndroid.js","sourceRoot":"","sources":["../../src/types/NotificationAndroid.ts"],"names":[],"mappings":"AAAA;;GAEG;AA+cH;;;;;;;;;GASG;AAEH,MAAM,CAAN,IAAY,0BAgBX;AAhBD,WAAY,0BAA0B;IACpC;;;OAGG;IACH,8FAAkB,CAAA;IAElB;;OAEG;IACH,mFAAY,CAAA;IAEZ;;OAEG;IACH,iFAAW,CAAA;AACb,CAAC,EAhBW,0BAA0B,KAA1B,0BAA0B,QAgBrC;AAqlBD;;;;;;GAMG;AACH,MAAM,CAAN,IAAY,oBAiBX;AAjBD,WAAY,oBAAoB;IAC9B;;OAEG;IACH,+DAAQ,CAAA;IAER;;OAEG;IACH,iEAAS,CAAA;IAET;;;;OAIG;IACH,iEAAS,CAAA;AACX,CAAC,EAjBW,oBAAoB,KAApB,oBAAoB,QAiB/B;AAED;;;;;;;;GAQG;AACH,MAAM,CAAN,IAAY,eAqBX;AArBD,WAAY,eAAe;IACzB,kCAAe,CAAA;IACf,gCAAa,CAAA;IACb,kCAAe,CAAA;IACf,kCAAe,CAAA;IACf,kCAAe,CAAA;IACf,kCAAe,CAAA;IACf,4CAAyB,CAAA;IACzB,wCAAqB,CAAA;IACrB,kCAAe,CAAA;IACf,oDAAiC,CAAA;IACjC,wCAAqB,CAAA;IACrB,sCAAmB,CAAA;IACnB,oCAAiB,CAAA;IACjB,oCAAiB,CAAA;IAEjB;;OAEG;IACH,iCAAc,CAAA;IACd,0CAAuB,CAAA;AACzB,CAAC,EArBW,eAAe,KAAf,eAAe,QAqB1B;AAED;;;;;;GAMG;AACH,MAAM,CAAN,IAAY,YAuBX;AAvBD,WAAY,YAAY;IACtB,2BAAW,CAAA;IACX,6BAAa,CAAA;IACb,+BAAe,CAAA;IACf,+BAAe,CAAA;IACf,+BAAe,CAAA;IACf,6BAAa,CAAA;IACb,mCAAmB,CAAA;IACnB,iCAAiB,CAAA;IACjB,uCAAuB,CAAA;IACvB,qCAAqB,CAAA;IACrB,6BAAa,CAAA;IACb,uCAAuB,CAAA;IACvB,qCAAqB,CAAA;IACrB,6BAAa,CAAA;IACb,mCAAmB,CAAA;IACnB,6BAAa,CAAA;IACb,iCAAiB,CAAA;IACjB,6BAAa,CAAA;IACb,+BAAe,CAAA;IACf,iCAAiB,CAAA;IACjB,iCAAiB,CAAA;IACjB,6BAAa,CAAA;AACf,CAAC,EAvBW,YAAY,KAAZ,YAAY,QAuBvB;AAED;;;;;;;;;GASG;AACH,MAAM,CAAN,IAAY,eAoBX;AApBD,WAAY,eAAe;IACzB;;OAEG;IACH,oDAAQ,CAAA;IAER;;OAEG;IACH,yDAAU,CAAA;IAEV;;OAEG;IACH,uDAAS,CAAA;IAET;;OAEG;IACH,2DAAW,CAAA;AACb,CAAC,EApBW,eAAe,KAAf,eAAe,QAoB1B;AAED;;;GAGG;AACH,MAAM,CAAN,IAAY,YAYX;AAZD,WAAY,YAAY;IACtB;;;OAGG;IACH,mEAAkB,CAAA;IAElB;;;OAGG;IACH,kEAAkB,CAAA;AACpB,CAAC,EAZW,YAAY,KAAZ,YAAY,QAYvB;AAED;;;;;;;GAOG;AACH,MAAM,CAAN,IAAY,yBAeX;AAfD,WAAY,yBAAyB;IACnC;;OAEG;IACH,uEAAO,CAAA;IAEP;;OAEG;IACH,+EAAW,CAAA;IAEX;;OAEG;IACH,iFAAY,CAAA;AACd,CAAC,EAfW,yBAAyB,KAAzB,yBAAyB,QAepC;AAED;;;;;;GAMG;AACH,MAAM,CAAN,IAAY,YAKX;AALD,WAAY,YAAY;IACtB,2DAAc,CAAA;IACd,qDAAW,CAAA;IACX,iDAAS,CAAA;IACT,yDAAa,CAAA;AACf,CAAC,EALW,YAAY,KAAZ,YAAY,QAKvB;AAED;;;;;;;;;;GAUG;AACH,MAAM,CAAN,IAAY,iBAiBX;AAjBD,WAAY,iBAAiB;IAC3B;;OAEG;IACH,+DAAW,CAAA;IAEX;;OAEG;IACH,6DAAU,CAAA;IAEV;;;;OAIG;IACH,8DAAW,CAAA;AACb,CAAC,EAjBW,iBAAiB,KAAjB,iBAAiB,QAiB5B;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,CAAN,IAAY,iBA+CX;AA/CD,WAAY,iBAAiB;IAC3B;;;;;OAKG;IACH,+DAAW,CAAA;IAEX;;;;;;OAMG;IACH,yDAAQ,CAAA;IAER;;;;;;;;;OASG;IACH,uDAAO,CAAA;IAEP;;;;;;;;;OASG;IACH,uDAAO,CAAA;IAEP;;;OAGG;IACH,yDAAQ,CAAA;AACV,CAAC,EA/CW,iBAAiB,KAAjB,iBAAiB,QA+C5B;AAED;;;;;;;;GAQG;AACH,MAAM,CAAN,IAAY,yBA6GX;AA7GD,WAAY,yBAAyB;IACnC;;OAEG;IACH,qFAAc,CAAA;IAEd;;OAEG;IACH,qFAAc,CAAA;IAEd;;OAEG;IACH,iFAAY,CAAA;IAEZ;;OAEG;IACH,2FAAiB,CAAA;IAEjB;;OAEG;IACH,mFAAa,CAAA;IAEb;;OAEG;IACH,6FAAkB,CAAA;IAElB;;OAEG;IACH,+FAAmB,CAAA;IAEnB;;OAEG;IACH,yGAAwB,CAAA;IAExB;;OAEG;IACH,iGAAoB,CAAA;IAEpB;;OAEG;IACH,yGAAwB,CAAA;IAExB;;OAEG;IACH,4GAA0B,CAAA;IAE1B;;;;;;OAMG;IACH,4GAA0B,CAAA;IAE1B;;OAEG;IACH,0FAAiB,CAAA;IAEjB;;OAEG;IACH,8FAAmB,CAAA;IAEnB;;OAEG;IACH,kGAAqB,CAAA;IAErB;;OAEG;IACH,0FAAiB,CAAA;IAEjB;;OAEG;IACH,sFAAe,CAAA;IAEf;;OAEG;IACH,0FAAiB,CAAA;IAEjB;;OAEG;IACH,oGAAsB,CAAA;IAEtB;;OAEG;IACH,gGAAoB,CAAA;IAEpB;;OAEG;IACH,8FAAmB,CAAA;AACrB,CAAC,EA7GW,yBAAyB,KAAzB,yBAAyB,QA6GpC;AAED;;;;;GAKG;AACH,MAAM,CAAN,IAAY,4BAgBX;AAhBD,WAAY,4BAA4B;IACtC,oIAAmC,CAAA;IACnC,wJAA6C,CAAA;IAC7C,yIAAqC,CAAA;IACrC,qIAAoC,CAAA;IACpC,uIAAoC,CAAA;IACpC,mJAA0C,CAAA;IAC1C,wJAA6C,CAAA;IAC7C,0JAA+C,CAAA;IAC/C,6IAAwC,CAAA;IACxC,2IAAsC,CAAA;IACtC,yJAA8C,CAAA;IAC9C,oJAA4C,CAAA;IAC5C,sJAAgD,CAAA;IAChD,wJAA8C,CAAA;IAC9C,wIAAqC,CAAA;AACvC,CAAC,EAhBW,4BAA4B,KAA5B,4BAA4B,QAgBvC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,CAAN,IAAY,gCA8BX;AA9BD,WAAY,gCAAgC;IAC1C;;;;;;OAMG;IACH,6FAAW,CAAA;IAEX;;;;;;;;;OASG;IACH,iGAAa,CAAA;IAEb;;;;;;OAMG;IACH,+FAAY,CAAA;AACd,CAAC,EA9BW,gCAAgC,KAAhC,gCAAgC,QA8B3C"}

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const version = "10.2.1";
+export declare const version = "10.3.0";

package/dist/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-notify-kit",
-  "version": "10.2.1",
+  "version": "10.3.0",
   "author": "Marco Crupi",
   "description": "Maintained Notifee-compatible fork for React Native — advanced local notifications for Android & iOS.",
   "main": "dist/index.js",

package/src/types/Notification.ts

@@ -358,9 +358,12 @@ export enum EventType {
   DISMISSED = 0,
 
   /**
-   * Event type is sent when a notification has been pressed by the user.
+   * Event type is sent when the user presses a notification body and body tap is enabled.
    *
-   * On Android, notifications must include an `android.pressAction` property for this event to trigger.
+   * On Android, omitted `android.pressAction` defaults to opening the app and can emit this
+   * event. Setting `android.pressAction` to `null` disables the notification body tap and
+   * prevents `PRESS`/`getInitialNotification()` from that body tap. Action buttons emit
+   * `ACTION_PRESS` separately.
    *
    * On iOS, this event is always sent when the user presses a notification.
    */