react-native-notify-kit 10.2.1 → 10.3.0

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

@@ -0,0 +1,180 @@
+package app.notifee.core;
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+
+import android.Manifest;
+import android.app.Notification;
+import android.app.NotificationChannel;
+import android.content.Context;
+import android.os.Bundle;
+import app.notifee.core.model.NotificationModel;
+import com.google.common.util.concurrent.ListenableFuture;
+import java.util.ArrayList;
+import java.util.concurrent.TimeUnit;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.RuntimeEnvironment;
+import org.robolectric.Shadows;
+import org.robolectric.annotation.Config;
+import org.robolectric.shadows.ShadowNotificationManager;
+
+@RunWith(RobolectricTestRunner.class)
+@Config(sdk = 34)
+public class NotificationManagerPressActionOptOutTest {
+  private static final String CHANNEL_ID = "press-action-opt-out-test-channel";
+
+  @Before
+  public void setUp() {
+    Context context = RuntimeEnvironment.getApplication();
+    ContextHolder.setApplicationContext(context);
+    Shadows.shadowOf(RuntimeEnvironment.getApplication())
+        .grantPermissions(Manifest.permission.POST_NOTIFICATIONS);
+    createChannel(context);
+
+    android.app.NotificationManager notificationManager =
+        (android.app.NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
+    notificationManager.cancelAll();
+  }
+
+  @Test
+  public void displayNotification_optOutPressActionOnAndroid12Plus_hasNoContentIntent()
+      throws Exception {
+    Notification notification =
+        displayNotification(buildNotificationModelWithOptOutPressAction("opt-out-android-12-plus"));
+
+    assertNull(
+        "pressAction opt-out must not set a body tap content intent on Android 12+",
+        notification.contentIntent);
+  }
+
+  @Test
+  @Config(sdk = 28)
+  public void displayNotification_optOutPressActionPreAndroid12_hasNoContentIntent()
+      throws Exception {
+    Notification notification =
+        displayNotification(buildNotificationModelWithOptOutPressAction("opt-out-pre-android-12"));
+
+    assertNull(
+        "pressAction opt-out must not set a body tap content intent before Android 12",
+        notification.contentIntent);
+  }
+
+  @Test
+  public void displayNotification_missingPressAction_keepsContentIntent() throws Exception {
+    Notification notification = displayNotification(buildNotificationModel("missing-press-action"));
+
+    assertNotNull(
+        "missing pressAction must synthesize the default body tap content intent",
+        notification.contentIntent);
+  }
+
+  @Test
+  public void displayNotification_actionButtonWithOptOutContent_keepsActionIntent()
+      throws Exception {
+    Notification notification =
+        displayNotification(buildNotificationModelWithOptOutPressActionAndAction("opt-out-action"));
+
+    assertNull(
+        "pressAction opt-out must only disable the body tap content intent",
+        notification.contentIntent);
+    assertNotNull("action array must be present", notification.actions);
+    assertEquals("one action must be built", 1, notification.actions.length);
+    assertNotNull(
+        "action button PendingIntent must remain independent of body tap opt-out",
+        notification.actions[0].actionIntent);
+  }
+
+  private static Notification displayNotification(NotificationModel notificationModel)
+      throws Exception {
+    ListenableFuture<Void> future = NotificationManager.displayNotification(notificationModel, null);
+    future.get(5, TimeUnit.SECONDS);
+
+    Context context = RuntimeEnvironment.getApplication();
+    android.app.NotificationManager notificationManager =
+        (android.app.NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
+    ShadowNotificationManager shadowNotificationManager = Shadows.shadowOf(notificationManager);
+    Notification notification =
+        shadowNotificationManager.getNotification(notificationModel.getHashCode());
+    assertNotNull("notification must be posted", notification);
+    return notification;
+  }
+
+  private static void createChannel(Context context) {
+    android.app.NotificationManager notificationManager =
+        (android.app.NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
+    if (notificationManager.getNotificationChannel(CHANNEL_ID) == null) {
+      NotificationChannel channel =
+          new NotificationChannel(
+              CHANNEL_ID,
+              "Press action opt-out test",
+              android.app.NotificationManager.IMPORTANCE_LOW);
+      notificationManager.createNotificationChannel(channel);
+    }
+  }
+
+  private static NotificationModel buildNotificationModel(String id) {
+    return NotificationModel.fromBundle(buildNotificationBundle(id));
+  }
+
+  private static NotificationModel buildNotificationModelWithOptOutPressAction(String id) {
+    Bundle notificationBundle = buildNotificationBundle(id);
+    Bundle androidBundle = notificationBundle.getBundle("android");
+    androidBundle.putBundle(
+        "pressAction", buildPressAction(NotificationPendingIntent.PRESS_ACTION_OPT_OUT_ID));
+    return NotificationModel.fromBundle(notificationBundle);
+  }
+
+  private static NotificationModel buildNotificationModelWithOptOutPressActionAndAction(String id) {
+    Bundle notificationBundle = buildNotificationBundle(id);
+    Bundle androidBundle = notificationBundle.getBundle("android");
+    androidBundle.putBundle(
+        "pressAction", buildPressAction(NotificationPendingIntent.PRESS_ACTION_OPT_OUT_ID));
+
+    Bundle action = new Bundle();
+    action.putString("title", "Reply");
+    action.putBundle("pressAction", buildPressAction("reply"));
+    ArrayList<Bundle> actions = new ArrayList<>();
+    actions.add(action);
+    androidBundle.putParcelableArrayList("actions", actions);
+
+    return NotificationModel.fromBundle(notificationBundle);
+  }
+
+  private static Bundle buildNotificationBundle(String id) {
+    Bundle notificationBundle = new Bundle();
+    notificationBundle.putString("id", id);
+    notificationBundle.putString("title", "Press action opt-out " + id);
+    notificationBundle.putString("body", "Body " + id);
+
+    Bundle androidBundle = new Bundle();
+    androidBundle.putString("channelId", CHANNEL_ID);
+    notificationBundle.putBundle("android", androidBundle);
+    return notificationBundle;
+  }
+
+  private static Bundle buildPressAction(String id) {
+    Bundle pressAction = new Bundle();
+    pressAction.putString("id", id);
+    return pressAction;
+  }
+}

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

@@ -0,0 +1,157 @@
+package app.notifee.core;
+
+import static app.notifee.core.NotificationPendingIntent.EVENT_TYPE_INTENT_KEY;
+import static app.notifee.core.NotificationPendingIntent.NOTIFICATION_ID_INTENT_KEY;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+import android.content.Context;
+import android.content.Intent;
+import android.os.Bundle;
+import app.notifee.core.event.InitialNotificationEvent;
+import app.notifee.core.event.MainComponentEvent;
+import app.notifee.core.event.NotificationEvent;
+import java.util.ArrayList;
+import java.util.List;
+import org.greenrobot.eventbus.Subscribe;
+import org.greenrobot.eventbus.ThreadMode;
+import org.junit.After;
+import org.junit.Before;
+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)
+@Config(sdk = 34)
+public class NotificationReceiverHandlerInitialNotificationTest {
+
+  private NotificationEventCapture capture;
+  private Context context;
+
+  @Before
+  public void setUp() {
+    context = RuntimeEnvironment.getApplication();
+    ContextHolder.setApplicationContext(context);
+    clearStickyEvents();
+    capture = new NotificationEventCapture();
+    EventBus.register(capture);
+  }
+
+  @After
+  public void tearDown() {
+    EventBus.unregister(capture);
+    clearStickyEvents();
+  }
+
+  @Test
+  public void handleNotification_typePress_postsNotificationEventAndInitialNotification() {
+    Intent intent =
+        buildHandlerIntent(
+            NotificationEvent.TYPE_PRESS,
+            buildNotificationBundle("handler-press"),
+            buildPressActionBundle("default", "default", "HandlerMainComponent"));
+
+    NotificationReceiverHandler.handleNotification(context, intent);
+
+    assertEquals("one NotificationEvent should be posted", 1, capture.events.size());
+    NotificationEvent event = capture.events.get(0);
+    assertEquals(NotificationEvent.TYPE_PRESS, event.getType());
+    assertEquals("handler-press", event.getNotification().getId());
+    assertNotNull("PRESS extras should be preserved", event.getExtras());
+    assertPressAction(event.getExtras(), "default", "default", "HandlerMainComponent");
+
+    InitialNotificationEvent initialNotificationEvent =
+        EventBus.getStickyEvent(InitialNotificationEvent.class);
+    assertNotNull("TYPE_PRESS should post InitialNotificationEvent", initialNotificationEvent);
+    assertEquals("handler-press", initialNotificationEvent.getNotificationModel().getId());
+    assertPressAction(
+        initialNotificationEvent.getExtras(), "default", "default", "HandlerMainComponent");
+  }
+
+  @Test
+  public void handleNotification_typeActionPressWithoutLaunch_postsCurrentInitialNotification() {
+    Intent intent =
+        buildHandlerIntent(
+            NotificationEvent.TYPE_ACTION_PRESS,
+            buildNotificationBundle("handler-action-no-launch"),
+            buildPressActionBundle("reply", null, null));
+
+    NotificationReceiverHandler.handleNotification(context, intent);
+
+    assertEquals("one NotificationEvent should be posted", 1, capture.events.size());
+    NotificationEvent event = capture.events.get(0);
+    assertEquals(NotificationEvent.TYPE_ACTION_PRESS, event.getType());
+    assertEquals("handler-action-no-launch", event.getNotification().getId());
+    assertNotNull("ACTION_PRESS extras should be preserved", event.getExtras());
+    assertPressAction(event.getExtras(), "reply", null, null);
+
+    InitialNotificationEvent initialNotificationEvent =
+        EventBus.getStickyEvent(InitialNotificationEvent.class);
+    assertNotNull(
+        "Android 12+ handler currently posts InitialNotificationEvent for no-launch ACTION_PRESS",
+        initialNotificationEvent);
+    assertEquals("handler-action-no-launch", initialNotificationEvent.getNotificationModel().getId());
+    assertPressAction(initialNotificationEvent.getExtras(), "reply", null, null);
+  }
+
+  private static Intent buildHandlerIntent(
+      int type, Bundle notificationBundle, Bundle pressActionBundle) {
+    Intent intent = new Intent();
+    intent.putExtra(EVENT_TYPE_INTENT_KEY, type);
+    intent.putExtra(NOTIFICATION_ID_INTENT_KEY, notificationBundle.getString("id").hashCode());
+    intent.putExtra("notification", notificationBundle);
+    intent.putExtra("pressAction", pressActionBundle);
+    return intent;
+  }
+
+  private static Bundle buildNotificationBundle(String id) {
+    Bundle notificationBundle = new Bundle();
+    notificationBundle.putString("id", id);
+    notificationBundle.putString("title", "Handler test " + id);
+    notificationBundle.putString("body", "Body " + id);
+
+    Bundle androidBundle = new Bundle();
+    androidBundle.putString("channelId", "handler-initial-test-channel");
+    androidBundle.putBoolean("autoCancel", false);
+    notificationBundle.putBundle("android", androidBundle);
+    return notificationBundle;
+  }
+
+  private static Bundle buildPressActionBundle(
+      String id, String launchActivity, String mainComponent) {
+    Bundle pressActionBundle = new Bundle();
+    pressActionBundle.putString("id", id);
+    if (launchActivity != null) {
+      pressActionBundle.putString("launchActivity", launchActivity);
+    }
+    if (mainComponent != null) {
+      pressActionBundle.putString("mainComponent", mainComponent);
+    }
+    return pressActionBundle;
+  }
+
+  private static void assertPressAction(
+      Bundle extras, String id, String launchActivity, String mainComponent) {
+    Bundle pressAction = extras.getBundle("pressAction");
+    assertNotNull("pressAction should be present", pressAction);
+    assertEquals(id, pressAction.getString("id"));
+    assertEquals(launchActivity, pressAction.getString("launchActivity"));
+    assertEquals(mainComponent, pressAction.getString("mainComponent"));
+  }
+
+  private static void clearStickyEvents() {
+    EventBus.removeStickEvent(InitialNotificationEvent.class);
+    EventBus.removeStickEvent(MainComponentEvent.class);
+  }
+
+  public static class NotificationEventCapture {
+    final List<NotificationEvent> events = new ArrayList<>();
+
+    @Subscribe(threadMode = ThreadMode.POSTING)
+    public void onNotificationEvent(NotificationEvent event) {
+      events.add(event);
+    }
+  }
+}

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

@@ -0,0 +1,169 @@
+package app.notifee.core;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Bundle;
+import app.notifee.core.event.InitialNotificationEvent;
+import app.notifee.core.event.MainComponentEvent;
+import app.notifee.core.event.NotificationEvent;
+import java.util.ArrayList;
+import java.util.List;
+import org.greenrobot.eventbus.Subscribe;
+import org.greenrobot.eventbus.ThreadMode;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.Robolectric;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.RuntimeEnvironment;
+import org.robolectric.android.controller.ServiceController;
+import org.robolectric.annotation.Config;
+
+@RunWith(RobolectricTestRunner.class)
+@Config(sdk = 28)
+public class ReceiverServiceInitialNotificationTest {
+
+  private NotificationEventCapture capture;
+  private ReceiverService service;
+  private ServiceController<ReceiverService> serviceController;
+
+  @Before
+  public void setUp() {
+    Context context = RuntimeEnvironment.getApplication();
+    ContextHolder.setApplicationContext(context);
+    clearStickyEvents();
+    capture = new NotificationEventCapture();
+    EventBus.register(capture);
+    serviceController = Robolectric.buildService(ReceiverService.class).create();
+    service = serviceController.get();
+  }
+
+  @After
+  public void tearDown() {
+    EventBus.unregister(capture);
+    serviceController.destroy();
+    clearStickyEvents();
+  }
+
+  @Test
+  public void onActionPressIntent_withoutLaunch_preservesCurrentNoInitialNotificationBehavior() {
+    Intent intent =
+        buildServiceIntent(
+            buildNotificationBundle("service-action-no-launch"),
+            buildPressActionBundle("reply", null, null));
+
+    service.onStartCommand(intent, 0, 1);
+
+    assertEquals("one NotificationEvent should be posted", 1, capture.events.size());
+    NotificationEvent event = capture.events.get(0);
+    assertEquals(NotificationEvent.TYPE_ACTION_PRESS, event.getType());
+    assertEquals("service-action-no-launch", event.getNotification().getId());
+    assertNotNull("ACTION_PRESS extras should be preserved", event.getExtras());
+    assertPressAction(event.getExtras(), "reply", null, null);
+
+    assertNull(
+        "pre-Android 12 ReceiverService currently does not post InitialNotificationEvent for"
+            + " no-launch ACTION_PRESS",
+        EventBus.getStickyEvent(InitialNotificationEvent.class));
+  }
+
+  @Test
+  public void onActionPressIntent_withLaunch_postsInitialNotificationAfterPendingIntentSend() {
+    Intent intent =
+        buildServiceIntent(
+            buildNotificationBundle("service-action-launch"),
+            buildPressActionBundle(
+                "reply-launch", TestLaunchActivity.class.getName(), "ServiceMainComponent"));
+
+    service.onStartCommand(intent, 0, 1);
+
+    assertEquals("one NotificationEvent should be posted", 1, capture.events.size());
+    NotificationEvent event = capture.events.get(0);
+    assertEquals(NotificationEvent.TYPE_ACTION_PRESS, event.getType());
+    assertEquals("service-action-launch", event.getNotification().getId());
+    assertNotNull("ACTION_PRESS extras should be preserved", event.getExtras());
+    assertPressAction(
+        event.getExtras(),
+        "reply-launch",
+        TestLaunchActivity.class.getName(),
+        "ServiceMainComponent");
+
+    InitialNotificationEvent initialNotificationEvent =
+        EventBus.getStickyEvent(InitialNotificationEvent.class);
+    assertNotNull(
+        "pre-Android 12 ReceiverService currently posts InitialNotificationEvent when ACTION_PRESS"
+            + " launches an activity",
+        initialNotificationEvent);
+    assertEquals("service-action-launch", initialNotificationEvent.getNotificationModel().getId());
+    assertPressAction(
+        initialNotificationEvent.getExtras(),
+        "reply-launch",
+        TestLaunchActivity.class.getName(),
+        "ServiceMainComponent");
+  }
+
+  private static Intent buildServiceIntent(Bundle notificationBundle, Bundle pressActionBundle) {
+    Intent intent = new Intent(RuntimeEnvironment.getApplication(), ReceiverService.class);
+    intent.setAction(ReceiverService.ACTION_PRESS_INTENT);
+    intent.putExtra("notification", notificationBundle);
+    intent.putExtra("pressAction", pressActionBundle);
+    return intent;
+  }
+
+  private static Bundle buildNotificationBundle(String id) {
+    Bundle notificationBundle = new Bundle();
+    notificationBundle.putString("id", id);
+    notificationBundle.putString("title", "ReceiverService test " + id);
+    notificationBundle.putString("body", "Body " + id);
+
+    Bundle androidBundle = new Bundle();
+    androidBundle.putString("channelId", "receiver-service-initial-test-channel");
+    androidBundle.putBoolean("autoCancel", false);
+    notificationBundle.putBundle("android", androidBundle);
+    return notificationBundle;
+  }
+
+  private static Bundle buildPressActionBundle(
+      String id, String launchActivity, String mainComponent) {
+    Bundle pressActionBundle = new Bundle();
+    pressActionBundle.putString("id", id);
+    if (launchActivity != null) {
+      pressActionBundle.putString("launchActivity", launchActivity);
+    }
+    if (mainComponent != null) {
+      pressActionBundle.putString("mainComponent", mainComponent);
+    }
+    return pressActionBundle;
+  }
+
+  private static void assertPressAction(
+      Bundle extras, String id, String launchActivity, String mainComponent) {
+    Bundle pressAction = extras.getBundle("pressAction");
+    assertNotNull("pressAction should be present", pressAction);
+    assertEquals(id, pressAction.getString("id"));
+    assertEquals(launchActivity, pressAction.getString("launchActivity"));
+    assertEquals(mainComponent, pressAction.getString("mainComponent"));
+  }
+
+  private static void clearStickyEvents() {
+    EventBus.removeStickEvent(InitialNotificationEvent.class);
+    EventBus.removeStickEvent(MainComponentEvent.class);
+  }
+
+  public static class TestLaunchActivity extends Activity {}
+
+  public static class NotificationEventCapture {
+    final List<NotificationEvent> events = new ArrayList<>();
+
+    @Subscribe(threadMode = ThreadMode.POSTING)
+    public void onNotificationEvent(NotificationEvent event) {
+      events.add(event);
+    }
+  }
+}

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

@@ -0,0 +1,116 @@
+package app.notifee.core.model;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertThrows;
+
+import android.os.Bundle;
+import androidx.core.app.NotificationCompat;
+import androidx.core.app.NotificationManagerCompat;
+import java.util.ArrayList;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+
+@RunWith(RobolectricTestRunner.class)
+public class ChannelModelTest {
+
+  @Test
+  public void fields_whenMissing_returnCurrentDefaults() {
+    ChannelModel model = ChannelModel.fromBundle(new Bundle());
+
+    assertEquals(NotificationManagerCompat.IMPORTANCE_DEFAULT, model.getImportance().intValue());
+    assertEquals(NotificationCompat.VISIBILITY_PRIVATE, model.getVisibility());
+    assertArrayEquals(new long[0], model.getVibrationPattern());
+    assertNull(model.getSound());
+  }
+
+  @Test
+  public void numericFields_withIntegerAndDoubleValues_preserveCurrentCoercion() {
+    Bundle integerBundle = new Bundle();
+    integerBundle.putInt("importance", NotificationManagerCompat.IMPORTANCE_HIGH);
+    integerBundle.putInt("visibility", NotificationCompat.VISIBILITY_SECRET);
+    ChannelModel integerModel = ChannelModel.fromBundle(integerBundle);
+
+    assertEquals(NotificationManagerCompat.IMPORTANCE_HIGH, integerModel.getImportance().intValue());
+    assertEquals(NotificationCompat.VISIBILITY_SECRET, integerModel.getVisibility());
+
+    Bundle doubleBundle = new Bundle();
+    doubleBundle.putDouble("importance", NotificationManagerCompat.IMPORTANCE_HIGH + 0.9d);
+    doubleBundle.putDouble("visibility", -1.9d);
+    ChannelModel doubleModel = ChannelModel.fromBundle(doubleBundle);
+
+    assertEquals(NotificationManagerCompat.IMPORTANCE_HIGH, doubleModel.getImportance().intValue());
+    assertEquals(NotificationCompat.VISIBILITY_SECRET, doubleModel.getVisibility());
+  }
+
+  @Test
+  public void numericFields_withExplicitNull_currentlyCoerceToZero() {
+    Bundle bundle = new Bundle();
+    bundle.putString("importance", null);
+    bundle.putString("visibility", null);
+    ChannelModel model = ChannelModel.fromBundle(bundle);
+
+    assertEquals(0, model.getImportance().intValue());
+    assertEquals(0, model.getVisibility());
+  }
+
+  @Test
+  public void numericFields_withUnsupportedTypes_currentlyThrowClassCastException() {
+    Bundle importanceBundle = new Bundle();
+    importanceBundle.putLong("importance", 4L);
+    assertThrows(
+        ClassCastException.class, () -> ChannelModel.fromBundle(importanceBundle).getImportance());
+
+    Bundle visibilityBundle = new Bundle();
+    visibilityBundle.putString("visibility", "1");
+    assertThrows(
+        ClassCastException.class, () -> ChannelModel.fromBundle(visibilityBundle).getVisibility());
+  }
+
+  @Test
+  public void vibrationPattern_missingEmptyIntegerAndUnsupportedValues_preserveCurrentBehavior() {
+    assertArrayEquals(new long[0], ChannelModel.fromBundle(new Bundle()).getVibrationPattern());
+
+    Bundle emptyBundle = new Bundle();
+    putRawParcelableArrayList(emptyBundle, "vibrationPattern", new ArrayList<Integer>());
+    assertArrayEquals(new long[0], ChannelModel.fromBundle(emptyBundle).getVibrationPattern());
+
+    ArrayList<Integer> vibrationPattern = new ArrayList<>();
+    vibrationPattern.add(100);
+    vibrationPattern.add(200);
+    Bundle validBundle = new Bundle();
+    putRawParcelableArrayList(validBundle, "vibrationPattern", vibrationPattern);
+
+    assertArrayEquals(new long[] {100L, 200L}, ChannelModel.fromBundle(validBundle).getVibrationPattern());
+
+    ArrayList<Object> invalidPattern = new ArrayList<>();
+    invalidPattern.add(100L);
+    Bundle invalidBundle = new Bundle();
+    putRawParcelableArrayList(invalidBundle, "vibrationPattern", invalidPattern);
+
+    assertThrows(
+        ClassCastException.class,
+        () -> ChannelModel.fromBundle(invalidBundle).getVibrationPattern());
+  }
+
+  @Test
+  public void sound_missingPresentAndExplicitNull_preserveCurrentBehavior() {
+    assertNull(ChannelModel.fromBundle(new Bundle()).getSound());
+
+    Bundle soundBundle = new Bundle();
+    soundBundle.putString("sound", "default");
+    assertEquals("default", ChannelModel.fromBundle(soundBundle).getSound());
+
+    Bundle nullSoundBundle = new Bundle();
+    nullSoundBundle.putString("sound", null);
+    assertNull(ChannelModel.fromBundle(nullSoundBundle).getSound());
+  }
+
+  @SuppressWarnings({"rawtypes", "unchecked"})
+  private static void putRawParcelableArrayList(
+      Bundle bundle, String key, ArrayList<?> arrayList) {
+    bundle.putParcelableArrayList(key, (ArrayList) arrayList);
+  }
+}

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

@@ -0,0 +1,71 @@
+package app.notifee.core.model;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThrows;
+
+import android.os.Bundle;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.robolectric.RobolectricTestRunner;
+
+@RunWith(RobolectricTestRunner.class)
+public class IntervalTriggerModelTest {
+
+  @Test
+  public void getInterval_returnsMinusOneWhenMissing() {
+    IntervalTriggerModel model = IntervalTriggerModel.fromBundle(new Bundle());
+
+    assertEquals(-1, model.getInterval());
+  }
+
+  @Test
+  public void getInterval_returnsIntegerValue() {
+    Bundle bundle = new Bundle();
+    bundle.putInt("interval", 15);
+
+    IntervalTriggerModel model = IntervalTriggerModel.fromBundle(bundle);
+
+    assertEquals(15, model.getInterval());
+  }
+
+  @Test
+  public void getInterval_truncatesDoubleValue() {
+    Bundle bundle = new Bundle();
+    bundle.putDouble("interval", 15.9d);
+
+    IntervalTriggerModel model = IntervalTriggerModel.fromBundle(bundle);
+
+    assertEquals(15, model.getInterval());
+  }
+
+  @Test
+  public void getInterval_returnsZeroForExplicitNull() {
+    Bundle bundle = new Bundle();
+    bundle.putString("interval", null);
+
+    IntervalTriggerModel model = IntervalTriggerModel.fromBundle(bundle);
+
+    assertEquals(0, model.getInterval());
+  }
+
+  @Test
+  public void getInterval_preservesClassCastForUnsupportedNumericTypes() {
+    Bundle longBundle = new Bundle();
+    longBundle.putLong("interval", 15L);
+    assertThrows(
+        ClassCastException.class, () -> IntervalTriggerModel.fromBundle(longBundle).getInterval());
+
+    Bundle floatBundle = new Bundle();
+    floatBundle.putFloat("interval", 15.9f);
+    assertThrows(
+        ClassCastException.class, () -> IntervalTriggerModel.fromBundle(floatBundle).getInterval());
+  }
+
+  @Test
+  public void getInterval_preservesClassCastForString() {
+    Bundle bundle = new Bundle();
+    bundle.putString("interval", "15");
+
+    assertThrows(ClassCastException.class, () -> IntervalTriggerModel.fromBundle(bundle).getInterval());
+  }
+}