cordova-plugin-reteno 2.1.0 → 2.2.0

package/docs/android.md

@@ -58,7 +58,7 @@ RetenoPlugin.init()
   });
 ```
 
-For Android SDK `2.9.4+`, you can also configure session duration and split session lifecycle flags during init:
+For Android SDK `2.9.6+`, you can also configure session duration and split session lifecycle flags during init:
 
 ```js
 RetenoPlugin.init({
@@ -66,7 +66,7 @@ RetenoPlugin.init({
   sessionDurationSeconds: 30 * 60,
   lifecycleTrackingOptions: {
     appLifecycleEnabled: true,
-    // ApplicationForgrounded/ApplicationBackgrounded events (disabled by default in 2.9.4)
+    // ApplicationForgrounded/ApplicationBackgrounded events (disabled by default)
     foregroundLifecycleEnabled: false,
     pushSubscriptionEnabled: true,
     // SessionStart/SessionEnd can now be managed separately
@@ -84,7 +84,7 @@ If you need advanced Reteno configuration (custom `RetenoConfig`, custom device
 
 ## Push notification listeners
 
-The plugin uses the listener-based API (`EventListener` / `Procedure`, Android SDK `2.9.4`) for all push events.
+The plugin uses the listener-based API (`EventListener` / `Procedure`, Android SDK `2.9.6`) for all push events.
 
 - `setOnRetenoPushDismissedListener(listener)` — called when a push notification is dismissed (swiped away).
 - `setOnRetenoCustomPushReceivedListener(listener)` — called when a custom push notification is received.
@@ -108,6 +108,23 @@ RetenoPlugin.removeOnRetenoPushDismissedListener(onDismissed);
 RetenoPlugin.removeOnRetenoCustomPushReceivedListener(onCustomReceived);
 ```
 
+## Notification grouping
+
+Android notifications can be assigned to a group using either a value from the push payload or a constant group ID. The configuration is stored natively and restored when the Android process starts, so it does not depend on the Cordova WebView being active.
+
+```js
+// Group notifications by the `chatId` field in the push payload.
+await RetenoPlugin.setNotificationGroupingRule({ payloadKey: 'chatId' });
+
+// Alternatively, assign all Reteno notifications to one group.
+await RetenoPlugin.setNotificationGroupingRule({ groupId: 'messages' });
+
+// Disable grouping.
+await RetenoPlugin.setNotificationGroupingRule(null);
+```
+
+This configures the group key on each notification. If you want Android to display a summary row for the group, the application must create its own notification with `setGroupSummary(true)` using the same group ID.
+
 ### Without Firebasex (Cordova)
 
 If you **do not need** `cordova-plugin-firebasex` features, you can still use Reteno Push on Android.

package/docs/api.md

@@ -12,17 +12,17 @@ Notes:
 
 | Method                                                           | Supported platform | Description                                                                                                                                                                                                                                                                                                                                                          |
 | ---------------------------------------------------------------- | ------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| [init](../www/cordova-plugin-reteno.js)                          | iOS, Android       | Initializes Reteno SDK. Accepts optional `RetenoInitializeOptions` with `accessKey`, `pauseInAppMessages`, `pausePushInAppMessages`, `inAppMessagesPauseBehaviour` (iOS), `lifecycleTrackingOptions`, `sessionDurationSeconds` (Android 2.9.4+, iOS 2.7.0+), `isAutomaticScreenReportingEnabled` (iOS; see note below) and `isDebugMode`. [Types](../types/index.ts) |
+| [init](../www/cordova-plugin-reteno.js)                          | iOS, Android       | Initializes Reteno SDK. Accepts optional `RetenoInitializeOptions` with `accessKey`, `pauseInAppMessages`, `pausePushInAppMessages`, `inAppMessagesPauseBehaviour` (iOS), `lifecycleTrackingOptions`, `sessionDurationSeconds` (Android 2.9.6+, iOS 2.7.2+), `isAutomaticScreenReportingEnabled` (iOS; see note below) and `isDebugMode`. [Types](../types/index.ts) |
 | [requestNotificationPermission](../www/cordova-plugin-reteno.js) | iOS, Android       | Requests push permission (iOS) or `POST_NOTIFICATIONS` (Android 13+). Returns `0` or `1` on Android (`RequestNotificationPermissionResult`) in [types](../types/index.ts).                                                                                                                                                                                           |
 | [setLifecycleTrackingOptions](../www/cordova-plugin-reteno.js)   | iOS, Android       | Configures automatic tracking for app lifecycle, push subscription, and session events. Android: applies immediately. iOS: supported only before initialization (stored and applied during `init(...)`). [Types](../types/index.ts)                                                                                                                                  |
 
 ### User data
 
-| Method                                                           | Supported platform | Description                                                                                      |
-| ---------------------------------------------------------------- | ------------------ | ------------------------------------------------------------------------------------------------ |
-| [setUserAttributes](../www/cordova-plugin-reteno.js)             | iOS, Android       | Supports `marketId` (Android 2.9.5+, iOS 2.7.1+). Pass `""` to clear. [Types](../types/index.ts) |
-| [setAnonymousUserAttributes](../www/cordova-plugin-reteno.js)    | iOS, Android       | Supports `marketId` (Android 2.9.5+, iOS 2.7.1+). Pass `""` to clear. [Types](../types/index.ts) |
-| [setMultiAccountUserAttributes](../www/cordova-plugin-reteno.js) | iOS, Android       | Supports `marketId` (Android 2.9.5+, iOS 2.7.1+). Pass `""` to clear. [Types](../types/index.ts) |
+| Method                                                           | Supported platform | Description                                                                                                             |
+| ---------------------------------------------------------------- | ------------------ | ----------------------------------------------------------------------------------------------------------------------- |
+| [setUserAttributes](../www/cordova-plugin-reteno.js)             | iOS, Android       | Supports `marketId` with the bundled Android 2.9.6+ and iOS 2.7.2+ SDKs. Pass `""` to clear. [Types](../types/index.ts) |
+| [setAnonymousUserAttributes](../www/cordova-plugin-reteno.js)    | iOS, Android       | Supports `marketId` with the bundled Android 2.9.6+ and iOS 2.7.2+ SDKs. Pass `""` to clear. [Types](../types/index.ts) |
+| [setMultiAccountUserAttributes](../www/cordova-plugin-reteno.js) | iOS, Android       | Supports `marketId` with the bundled Android 2.9.6+ and iOS 2.7.2+ SDKs. Pass `""` to clear. [Types](../types/index.ts) |
 
 ### Event tracking
 
@@ -53,9 +53,12 @@ Notes:
 | [setWillPresentNotificationOptions](../www/cordova-plugin-reteno.js)         | iOS                | Sets presentation options for foreground notifications. Optionally emits `reteno-push-received`. [Types](../types/index.ts)                                                                                                                                                                                                                                                       |
 | [setDidReceiveNotificationResponseHandler](../www/cordova-plugin-reteno.js)  | iOS                | Enables a response handler for notification taps. Optionally emits `reteno-notification-clicked`. [Types](../types/index.ts)                                                                                                                                                                                                                                                      |
 | [updateDefaultNotificationChannel](../www/cordova-plugin-reteno.js)          | Android            | Updates the default notification channel name and description for existing users. [Types](../types/index.ts)                                                                                                                                                                                                                                                                      |
+| [setNotificationGroupingRule](../www/cordova-plugin-reteno.js)               | Android            | Groups notifications by a push payload field or a constant group ID. The rule is persisted natively and restored before background push handling. Pass `null` to disable. [Types](../types/index.ts)                                                                                                                                                                              |
 
 ### In-app messages
 
+Bundled native SDKs support the `DOES_NOT_EQUAL` in-app rule condition: Android SDK 2.9.6+ and iOS SDK 2.7.2+.
+
 | Method                                                                            | Supported platform | Description                                                                                                                                                       |
 | --------------------------------------------------------------------------------- | ------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | [pauseInAppMessages](../www/cordova-plugin-reteno.js)                             | iOS, Android       | Pauses or resumes in-app messages at runtime. Pass `true` to pause, `false` to resume.                                                                            |
@@ -99,7 +102,7 @@ RetenoPlugin.init()
 // pausePushInAppMessages: pauses in-app messages triggered by push notifications.
 // inAppMessagesPauseBehaviour: (iOS) defines handling while paused: 'SKIP_IN_APPS' or 'POSTPONE_IN_APPS'.
 // lifecycleTrackingOptions: configures app lifecycle, push subscription, and session event tracking ('ALL', 'NONE', or an object).
-// sessionDurationSeconds (Android 2.9.4+, iOS 2.7.0+): optional session reset duration.
+// sessionDurationSeconds (Android 2.9.6+, iOS 2.7.2+): optional session reset duration.
 // isAutomaticScreenReportingEnabled: enables automatic native screen view tracking on iOS.
 //   Keep this false in Cordova/Ionic WebView apps (including Android demos).
 //   Defaults to false. Note: in Cordova/Ionic apps the UI runs inside a single WebView,
@@ -116,13 +119,13 @@ RetenoPlugin.init({
   inAppMessagesPauseBehaviour: 'SKIP_IN_APPS', // iOS
   isAutomaticScreenReportingEnabled: false, // keep false for hybrid/WebView apps
   isDebugMode: true, // enables debug mode
-  sessionDurationSeconds: 30 * 60, // Android 2.9.4+, iOS 2.7.0+: 30 minutes
+  sessionDurationSeconds: 30 * 60, // Android 2.9.6+, iOS 2.7.2+: 30 minutes
   lifecycleTrackingOptions: {
     appLifecycleEnabled: true,
     foregroundLifecycleEnabled: false,
     pushSubscriptionEnabled: true,
     sessionStartEventsEnabled: true,
-    sessionEndEventsEnabled: false, // Android 2.9.4 default
+    sessionEndEventsEnabled: false,
   },
 })
   .then(() => console.log('init: OK'))
@@ -483,7 +486,7 @@ Subscribe to push received events while the app is running.
 
 Notes:
 
-- On Android this is based on the SDK 2.9.4 `EventListener` / `Procedure` API (`RetenoNotifications.getReceived()`).
+- On Android this is based on the SDK 2.9.6 `EventListener` / `Procedure` API (`RetenoNotifications.getReceived()`).
 - This listener is not a replacement for `getInitialNotification()` (cold start): if the app was launched by tapping a notification, use `getInitialNotification()`.
 
 ```js
@@ -565,6 +568,23 @@ RetenoPlugin.updateDefaultNotificationChannel({
   .catch((err) => console.error('updateDefaultNotificationChannel: ERROR', err));
 ```
 
+### setNotificationGroupingRule example
+
+Configures Android notification grouping without a JavaScript callback, so the rule also works when the WebView is not running. Payload type: `NotificationGroupingRule` in [types](../types/index.ts).
+
+```js
+// Use the value of `chatId` from each push payload as its Android group key.
+await RetenoPlugin.setNotificationGroupingRule({ payloadKey: 'chatId' });
+
+// Or put every Reteno notification into one constant group.
+await RetenoPlugin.setNotificationGroupingRule({ groupId: 'messages' });
+
+// Disable grouping.
+await RetenoPlugin.setNotificationGroupingRule(null);
+```
+
+The SDK assigns `NotificationCompat.Builder.setGroup(...)`; displaying a group-summary notification remains the application's responsibility.
+
 ### getAppInboxMessages example
 
 Fetches paginated App Inbox messages. Payload type: `GetAppInboxMessagesPayload` in [types](../types/index.ts).

package/docs/ios.md

@@ -68,12 +68,12 @@ target 'App' do
 
   target 'NotificationServiceExtension' do
     inherit! :search_paths
-    pod 'Reteno', '2.7.0'
+    pod 'Reteno', '2.7.3'
   end
 
   target 'NotificationContentExtension' do
     inherit! :search_paths
-    pod 'Reteno', '2.7.0'
+    pod 'Reteno', '2.7.3'
   end
 end
 ```
@@ -186,12 +186,12 @@ target 'App' do
 
   target 'NotificationServiceExtension' do
     inherit! :search_paths
-    pod 'Reteno', '2.7.0'
+    pod 'Reteno', '2.7.3'
   end
 
   target 'NotificationContentExtension' do
     inherit! :search_paths
-    pod 'Reteno', '2.7.0'
+    pod 'Reteno', '2.7.3'
   end
 end
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cordova-plugin-reteno",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "The Reteno Cordova Plugin for Mobile Customer Engagement and Analytics solutions",
   "types": "./types/index.ts",
   "files": [

package/plugin.xml

@@ -1,5 +1,5 @@
 <?xml version='1.0' encoding='utf-8'?>
-<plugin id="cordova-plugin-reteno" version="2.1.0" xmlns="http://apache.org/cordova/ns/plugins/1.0" xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schemas.android.com/tools">
+<plugin id="cordova-plugin-reteno" version="2.2.0" xmlns="http://apache.org/cordova/ns/plugins/1.0" xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schemas.android.com/tools">
     <name>cordova-plugin-reteno</name>
     <engines>
         <engine name="cordova-android" version=">=12.0.0" />
@@ -22,6 +22,10 @@
 
     <config-file target="AndroidManifest.xml" parent="/manifest/application">
         <meta-data android:name="com.reteno.SDK_ACCESS_KEY" android:value="$SDK_ACCESS_KEY" />
+        <provider
+            android:name="com.reteno.plugin.RetenoNotificationGroupingRuleProvider"
+            android:authorities="${applicationId}.reteno.notification-grouping-rule"
+            android:exported="false" />
     </config-file>
 
   <config-file target="config.xml" parent="/*">
@@ -45,6 +49,12 @@
   <source-file 
       src="src/android/app/src/main/java/com/reteno/plugin/RetenoUtil.java" 
       target-dir="src/com/reteno/plugin" />
+  <source-file
+      src="src/android/app/src/main/java/com/reteno/plugin/RetenoNotificationGroupingRuleProvider.java"
+      target-dir="src/com/reteno/plugin" />
+  <source-file
+      src="src/android/app/src/main/java/com/reteno/plugin/RetenoNotificationSummaryManager.java"
+      target-dir="src/com/reteno/plugin" />
 </platform>
 
 <platform name="ios">
@@ -58,7 +68,7 @@
 
   <podspec>
     <pods>
-      <pod name="Reteno" spec="2.7.1" />
+      <pod name="Reteno" spec="2.7.3" />
       <pod name="FirebaseMessaging" />
     </pods>
   </podspec>

package/src/android/app/build.gradle

@@ -1,6 +1,6 @@
 apply plugin: 'com.android.application'
 
-def retenoFcmVersion = '2.9.4'
+def retenoFcmVersion = '2.10.1'
 
 android {
     namespace 'com.reteno.plugin'

package/src/android/app/src/main/AndroidManifest.xml

@@ -2,6 +2,11 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     package="com.reteno.plugin">
 
-    <application />
+    <application>
+        <provider
+            android:name="com.reteno.plugin.RetenoNotificationGroupingRuleProvider"
+            android:authorities="${applicationId}.reteno.notification-grouping-rule"
+            android:exported="false" />
+    </application>
 
 </manifest>

package/src/android/app/src/main/java/com/reteno/plugin/RetenoNotificationGroupingRuleProvider.java

@@ -0,0 +1,117 @@
+package com.reteno.plugin;
+
+import android.content.ContentProvider;
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.database.Cursor;
+import android.net.Uri;
+import android.text.TextUtils;
+
+import com.reteno.push.RetenoNotifications;
+
+import java.util.Map;
+
+/**
+ * Restores the declarative notification grouping rule before services handle a push.
+ * This keeps grouping available when the Cordova WebView has not started yet.
+ */
+public final class RetenoNotificationGroupingRuleProvider extends ContentProvider {
+  private static final String PREFERENCES = "com.reteno.plugin.notification-grouping-rule";
+  private static final String PAYLOAD_KEY = "payloadKey";
+  private static final String GROUP_ID = "groupId";
+  private static final String SHOW_SUMMARY = "showSummary";
+
+  @Override
+  public boolean onCreate() {
+    Context context = getContext();
+    if (context != null) {
+      restore(context);
+    }
+    return true;
+  }
+
+  static void configure(Context context, String payloadKey, String groupId, boolean showSummary) {
+    SharedPreferences.Editor editor = preferences(context).edit().clear();
+    if (!TextUtils.isEmpty(payloadKey)) {
+      editor.putString(PAYLOAD_KEY, payloadKey);
+    } else if (!TextUtils.isEmpty(groupId)) {
+      editor.putString(GROUP_ID, groupId);
+    }
+    if (showSummary) {
+      editor.putBoolean(SHOW_SUMMARY, true);
+    }
+    // Persist before returning so a process restart cannot lose a just-configured rule.
+    editor.commit();
+    install(context, payloadKey, groupId, showSummary);
+  }
+
+  private static void restore(Context context) {
+    SharedPreferences preferences = preferences(context);
+    install(
+      context,
+      preferences.getString(PAYLOAD_KEY, null),
+      preferences.getString(GROUP_ID, null),
+      preferences.getBoolean(SHOW_SUMMARY, false)
+    );
+  }
+
+  /** Resolves the group a received push belongs to under the persisted rule. */
+  static String resolveGroup(Context context, Map<String, String> payload) {
+    SharedPreferences preferences = preferences(context);
+    String payloadKey = preferences.getString(PAYLOAD_KEY, null);
+    if (!TextUtils.isEmpty(payloadKey)) {
+      String value = payload.get(payloadKey);
+      return TextUtils.isEmpty(value) ? null : value;
+    }
+    String groupId = preferences.getString(GROUP_ID, null);
+    return TextUtils.isEmpty(groupId) ? null : groupId;
+  }
+
+  private static SharedPreferences preferences(Context context) {
+    return context.getSharedPreferences(PREFERENCES, Context.MODE_PRIVATE);
+  }
+
+  private static void install(Context context, String payloadKey, String groupId, boolean showSummary) {
+    if (!TextUtils.isEmpty(payloadKey)) {
+      RetenoNotifications.setGroupingRule((Map<String, String> payload) -> {
+        String value = payload.get(payloadKey);
+        return TextUtils.isEmpty(value) ? null : value;
+      });
+    } else if (!TextUtils.isEmpty(groupId)) {
+      RetenoNotifications.setGroupingRule((Map<String, String> payload) -> groupId);
+    } else {
+      RetenoNotifications.setGroupingRule(null);
+    }
+    RetenoNotificationSummaryManager.setEnabled(
+      context,
+      showSummary && (!TextUtils.isEmpty(payloadKey) || !TextUtils.isEmpty(groupId)),
+      !TextUtils.isEmpty(payloadKey) ? "payloadKey:" + payloadKey : "groupId:" + groupId
+    );
+  }
+
+  @Override
+  public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) {
+    return null;
+  }
+
+  @Override
+  public String getType(Uri uri) {
+    return null;
+  }
+
+  @Override
+  public Uri insert(Uri uri, ContentValues values) {
+    return null;
+  }
+
+  @Override
+  public int delete(Uri uri, String selection, String[] selectionArgs) {
+    return 0;
+  }
+
+  @Override
+  public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
+    return 0;
+  }
+}

package/src/android/app/src/main/java/com/reteno/plugin/RetenoNotificationSummaryManager.java

@@ -0,0 +1,262 @@
+package com.reteno.plugin;
+
+import android.Manifest;
+import android.app.Notification;
+import android.app.NotificationChannel;
+import android.app.NotificationManager;
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Looper;
+import android.service.notification.StatusBarNotification;
+
+import androidx.core.app.ActivityCompat;
+import androidx.core.app.NotificationCompat;
+import androidx.core.app.NotificationManagerCompat;
+
+import com.reteno.core.util.Procedure;
+import com.reteno.push.RetenoNotifications;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+
+/** Maintains optional Android group-summary notifications for Reteno pushes. */
+final class RetenoNotificationSummaryManager {
+  private static final String SUMMARY_CHANNEL_ID = "reteno_group_summary";
+  private static final String SUMMARY_TAG_PREFIX = "com.reteno.plugin.group-summary:";
+  private static final int SUMMARY_NOTIFICATION_ID = 1;
+  private static final int MAX_POST_ATTEMPTS = 25;
+  private static final int MAX_REMOVAL_ATTEMPTS = 10;
+  private static final long RETRY_DELAY_MS = 200L;
+
+  private static RetenoNotificationSummaryManager instance;
+
+  private final Context context;
+  private final Handler handler = new Handler(Looper.getMainLooper());
+  private final NotificationManagerCompat notificationManager;
+
+  private Procedure<Bundle> receivedListener;
+  private Procedure<Bundle> clickListener;
+  private Procedure<Bundle> closeListener;
+  private boolean enabled;
+  private String ruleIdentity;
+
+  private RetenoNotificationSummaryManager(Context context) {
+    this.context = context.getApplicationContext();
+    this.notificationManager = NotificationManagerCompat.from(this.context);
+  }
+
+  static synchronized void setEnabled(Context context, boolean enabled, String ruleIdentity) {
+    if (instance == null) {
+      instance = new RetenoNotificationSummaryManager(context);
+    }
+    if (enabled) {
+      instance.enable(ruleIdentity);
+    } else {
+      instance.disable();
+    }
+  }
+
+  private void enable(String ruleIdentity) {
+    if (enabled) {
+      if (Objects.equals(this.ruleIdentity, ruleIdentity)) {
+        return;
+      }
+      // The grouping rule may have changed since we were last enabled (e.g. constant group
+      // "A" -> "B"). Group "A" will never receive another received/click/close event under
+      // the new rule, so its summary would otherwise be orphaned forever. Drop any pending
+      // retry first - it closed over the old group and would otherwise recreate a stale
+      // summary via reconcile() right after we cancel it below - then cancel every summary
+      // this manager owns; each will be rebuilt from scratch as traffic for the new rule
+      // comes in. cancelAllSummaries() only touches our own SUMMARY_TAG_PREFIX-tagged
+      // notifications, so it never disturbs a group some other feature of the host app uses.
+      handler.removeCallbacksAndMessages(null);
+      cancelAllSummaries();
+      this.ruleIdentity = ruleIdentity;
+      return;
+    }
+    enabled = true;
+    this.ruleIdentity = ruleIdentity;
+    createSummaryChannel();
+
+    receivedListener = this::onReceived;
+    clickListener = this::onRemoved;
+    closeListener = this::onRemoved;
+    RetenoNotifications.getReceived().addListener(receivedListener);
+    RetenoNotifications.getClick().addListener(clickListener);
+    RetenoNotifications.getClose().addListener(closeListener);
+  }
+
+  private void disable() {
+    enabled = false;
+    ruleIdentity = null;
+    handler.removeCallbacksAndMessages(null);
+    if (receivedListener != null) {
+      RetenoNotifications.getReceived().removeListener(receivedListener);
+      receivedListener = null;
+    }
+    if (clickListener != null) {
+      RetenoNotifications.getClick().removeListener(clickListener);
+      clickListener = null;
+    }
+    if (closeListener != null) {
+      RetenoNotifications.getClose().removeListener(closeListener);
+      closeListener = null;
+    }
+    cancelAllSummaries();
+  }
+
+  private void createSummaryChannel() {
+    NotificationChannel channel = new NotificationChannel(
+      SUMMARY_CHANNEL_ID,
+      "Grouped notifications summary",
+      NotificationManager.IMPORTANCE_DEFAULT
+    );
+    notificationManager.createNotificationChannel(channel);
+  }
+
+  private void onReceived(Bundle bundle) {
+    String group = resolveGroup(bundle);
+    if (group == null) {
+      return;
+    }
+    awaitChildAndReconcile(group, notificationId(bundle), 0);
+  }
+
+  private void awaitChildAndReconcile(String group, int notificationId, int attempt) {
+    if (!enabled) {
+      return;
+    }
+    if (hasChild(group, notificationId) || attempt >= MAX_POST_ATTEMPTS) {
+      reconcile(group);
+      return;
+    }
+    handler.postDelayed(
+      () -> awaitChildAndReconcile(group, notificationId, attempt + 1),
+      RETRY_DELAY_MS
+    );
+  }
+
+  private void onRemoved(Bundle bundle) {
+    if (!enabled) {
+      return;
+    }
+    String group = resolveGroup(bundle);
+    if (group == null) {
+      return;
+    }
+    awaitRemovalAndReconcile(group, notificationId(bundle), 0);
+  }
+
+  private void awaitRemovalAndReconcile(String group, int notificationId, int attempt) {
+    if (!enabled) {
+      return;
+    }
+    if (hasChild(group, notificationId) && attempt < MAX_REMOVAL_ATTEMPTS) {
+      handler.postDelayed(
+        () -> awaitRemovalAndReconcile(group, notificationId, attempt + 1),
+        RETRY_DELAY_MS
+      );
+      return;
+    }
+    reconcile(group);
+  }
+
+  private String resolveGroup(Bundle bundle) {
+    return RetenoNotificationGroupingRuleProvider.resolveGroup(context, toStringMap(bundle));
+  }
+
+  private Map<String, String> toStringMap(Bundle bundle) {
+    Map<String, String> payload = new HashMap<>();
+    if (bundle == null) {
+      return payload;
+    }
+    for (String key : bundle.keySet()) {
+      Object value = bundle.get(key);
+      payload.put(key, value == null ? null : value.toString());
+    }
+    return payload;
+  }
+
+  private int notificationId(Bundle bundle) {
+    String interactionId = bundle == null ? null : bundle.getString("es_interaction_id");
+    return interactionId == null ? 1 : interactionId.hashCode();
+  }
+
+  private boolean hasChild(String group, int notificationId) {
+    for (StatusBarNotification sbn : notificationManager.getActiveNotifications()) {
+      if (sbn.getId() == notificationId && isChildInGroup(sbn.getNotification(), group)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  private void reconcile(String group) {
+    if (!enabled) {
+      return;
+    }
+
+    int childCount = 0;
+    for (StatusBarNotification sbn : notificationManager.getActiveNotifications()) {
+      if (isChildInGroup(sbn.getNotification(), group)) {
+        childCount++;
+      }
+    }
+
+    String tag = summaryTag(group);
+    if (childCount < 2) {
+      notificationManager.cancel(tag, SUMMARY_NOTIFICATION_ID);
+      return;
+    }
+    if (ActivityCompat.checkSelfPermission(context, Manifest.permission.POST_NOTIFICATIONS)
+      != PackageManager.PERMISSION_GRANTED) {
+      return;
+    }
+
+    Notification summary = new NotificationCompat.Builder(context, SUMMARY_CHANNEL_ID)
+      .setContentTitle("New notifications")
+      .setContentText("You have " + childCount + " new notifications")
+      .setSmallIcon(resolveSmallIcon())
+      .setGroup(group)
+      .setGroupSummary(true)
+      .setGroupAlertBehavior(NotificationCompat.GROUP_ALERT_CHILDREN)
+      .setOnlyAlertOnce(true)
+      .build();
+
+    notificationManager.notify(tag, SUMMARY_NOTIFICATION_ID, summary);
+  }
+
+  /**
+   * The launcher icon (context.getApplicationInfo().icon) is commonly an adaptive icon on modern
+   * apps, which is not a valid notification small icon and can make the system reject the
+   * notification. Reuse the plain vector drawable the Reteno Android SDK itself ships and falls
+   * back to (RetenoSdkPush's "reteno_default_push_icon"), which is guaranteed to be merged into
+   * any app that depends on the SDK, instead of ever touching the launcher icon.
+   */
+  private int resolveSmallIcon() {
+    int icon = context.getResources().getIdentifier(
+      "reteno_default_push_icon", "drawable", context.getPackageName()
+    );
+    return icon != 0 ? icon : android.R.drawable.ic_dialog_info;
+  }
+
+  private boolean isChildInGroup(Notification notification, String group) {
+    return group.equals(notification.getGroup()) && !NotificationCompat.isGroupSummary(notification);
+  }
+
+  private String summaryTag(String group) {
+    return SUMMARY_TAG_PREFIX + group;
+  }
+
+  private void cancelAllSummaries() {
+    for (StatusBarNotification sbn : notificationManager.getActiveNotifications()) {
+      String tag = sbn.getTag();
+      if (tag != null && tag.startsWith(SUMMARY_TAG_PREFIX)) {
+        notificationManager.cancel(tag, sbn.getId());
+      }
+    }
+  }
+}

package/src/android/app/src/main/java/com/reteno/plugin/RetenoPlugin.java

@@ -353,6 +353,25 @@ public class RetenoPlugin extends CordovaPlugin {
       return true;
     }
 
+    if ("setNotificationGroupingRule".equals(action)) {
+      Activity activity = cordova.getActivity();
+      if (activity == null) {
+        callbackContext.error("Reteno Android SDK Error: Activity is null.");
+        return true;
+      }
+      activity.runOnUiThread(new Runnable() {
+        @Override
+        public void run() {
+          try {
+            setNotificationGroupingRule(args, callbackContext);
+          } catch (Exception e) {
+            callbackContext.error("Reteno Android SDK Error: " + e.getLocalizedMessage());
+          }
+        }
+      });
+      return true;
+    }
+
     if ("getAppInboxMessages".equals(action)) {
       cordova.getThreadPool().execute(new Runnable() {
         @Override
@@ -608,7 +627,7 @@ public class RetenoPlugin extends CordovaPlugin {
   }
 
   /**
-   * Register notification event listeners using the SDK 2.9.4 EventListener API.
+   * Register notification event listeners using the SDK 2.9.6 EventListener API.
    * Each listener is a direct {@link Procedure} implementation — no reflection needed.
    */
   private void registerNotificationListeners() {
@@ -1181,7 +1200,7 @@ public class RetenoPlugin extends CordovaPlugin {
         ? payload.optBoolean("sessionStartEventsEnabled", legacySessionEventsEnabled)
         : legacySessionEventsEnabled;
 
-      // SDK 2.9.4 default for session end is disabled unless explicitly enabled.
+      // SDK default for session end is disabled unless explicitly enabled.
       boolean sessionEndEventsEnabled = payload.has("sessionEndEventsEnabled")
         ? payload.optBoolean("sessionEndEventsEnabled", false)
         : (payload.has("sessionEventsEnabled") ? legacySessionEventsEnabled : false);
@@ -1320,6 +1339,61 @@ public class RetenoPlugin extends CordovaPlugin {
     }
   }
 
+  private void setNotificationGroupingRule(JSONArray args, CallbackContext callbackContext) {
+    Object arg0 = (args == null || args.length() == 0) ? null : args.opt(0);
+    if (arg0 instanceof JSONArray) {
+      arg0 = ((JSONArray) arg0).opt(0);
+    }
+
+    if (arg0 == null || arg0 == JSONObject.NULL) {
+      RetenoNotificationGroupingRuleProvider.configure(
+        cordova.getActivity().getApplicationContext(), null, null, false
+      );
+      callbackContext.success(1);
+      return;
+    }
+
+    if (!(arg0 instanceof JSONObject)) {
+      callbackContext.error("Invalid argument: expected null or an object with payloadKey or groupId");
+      return;
+    }
+
+    JSONObject config = (JSONObject) arg0;
+    Object rawPayloadKey = config.opt("payloadKey");
+    Object rawGroupId = config.opt("groupId");
+    Object rawShowSummary = config.opt("showSummary");
+    if ((rawPayloadKey != null && rawPayloadKey != JSONObject.NULL && !(rawPayloadKey instanceof String))
+      || (rawGroupId != null && rawGroupId != JSONObject.NULL && !(rawGroupId instanceof String))) {
+      callbackContext.error("Invalid argument: payloadKey and groupId must be strings");
+      return;
+    }
+    if (rawShowSummary != null && rawShowSummary != JSONObject.NULL
+      && !(rawShowSummary instanceof Boolean)) {
+      callbackContext.error("Invalid argument: showSummary must be a boolean");
+      return;
+    }
+
+    String payloadKey = rawPayloadKey instanceof String ? (String) rawPayloadKey : null;
+    String groupId = rawGroupId instanceof String ? (String) rawGroupId : null;
+    payloadKey = payloadKey == null ? null : payloadKey.trim();
+    groupId = groupId == null ? null : groupId.trim();
+
+    boolean hasPayloadKey = !TextUtils.isEmpty(payloadKey);
+    boolean hasGroupId = !TextUtils.isEmpty(groupId);
+    if (hasPayloadKey == hasGroupId) {
+      callbackContext.error("Invalid argument: provide exactly one of payloadKey or groupId");
+      return;
+    }
+
+    RetenoNotificationGroupingRuleProvider.configure(
+      cordova.getActivity().getApplicationContext(),
+      hasPayloadKey ? payloadKey : null,
+      hasGroupId ? groupId : null,
+      rawShowSummary instanceof Boolean && (Boolean) rawShowSummary
+    );
+    callbackContext.success(1);
+  }
+
   private void getAppInboxMessages(JSONArray args, CallbackContext callbackContext) throws JSONException {
     if (args == null || args.length() == 0) {
       callbackContext.error("Missing argument: payload");

package/src/android/reteno.gradle

@@ -5,7 +5,7 @@ allprojects {
     }
 }
 
-def retenoFcmVersion = '2.9.5'
+def retenoFcmVersion = '2.10.1'
 
 def firebaseMessagingVersion = '23.1.0'
 

package/src/ios/RetenoPlugin.swift

@@ -117,7 +117,7 @@ class RetenoPlugin: CDVPlugin {
       isAutomaticScreenReportingEnabled: screenReportingEnabled,
       isAutomaticAppLifecycleReportingEnabled: lifecycleAppEnabled,
       isApplicationForegroundLifecycleReportingEnabled: lifecycleForegroundEnabled,
-      isAutomaticPushSubsriptionReportingEnabled: lifecyclePushEnabled,
+      isAutomaticPushSubscriptionReportingEnabled: lifecyclePushEnabled,
       sessionConfiguration: RetenoSessionConfiguration(
         sessionDuration: sessionDurationSeconds,
         isSessionStartReportingEnabled: lifecycleSessionStartEnabled,

package/types/index.ts

@@ -23,7 +23,7 @@ export type UserAttributesAnonymous = {
    * Market ID. Max 64 chars; latin letters, digits, '-' and '_' are allowed.
    * Pass `""` (empty string) to clear the value on the server.
    * Passing `null` or omitting the field has no effect (the existing value is kept).
-   * Available on Android 2.9.5+ and iOS 2.7.1+.
+   * Available with the bundled Android 2.9.6+ and iOS 2.7.2+ SDKs.
    */
   marketId?: string;
 };
@@ -104,7 +104,7 @@ export type RetenoInitializeOptions = {
   inAppMessagesPauseBehaviour?: InAppPauseBehaviour;
   isAutomaticScreenReportingEnabled?: boolean;
   lifecycleTrackingOptions?: LifecycleTrackingOptions;
-  /** Session reset duration in seconds (Android 2.9.4+, iOS 2.7.0+). */
+  /** Session reset duration in seconds (supported by the bundled Android 2.9.6+ and iOS 2.7.2+ SDKs). */
   sessionDurationSeconds?: number;
   /** Enables Reteno debug mode for near real-time event monitoring. Use only with test devices. */
   isDebugMode?: boolean;
@@ -154,6 +154,14 @@ export type NotificationChannelConfig = {
   description: string;
 };
 
+/**
+ * Android notification grouping rule. The rule is persisted natively so it
+ * remains available when a push is handled before the WebView starts.
+ */
+export type NotificationGroupingRule =
+  | { payloadKey: string; groupId?: never; showSummary?: boolean }
+  | { groupId: string; payloadKey?: never; showSummary?: boolean };
+
 export type AppInboxStatus = 'OPENED' | 'UNOPENED';
 
 export type AppInboxMessage = {

package/www/cordova-plugin-reteno.js

@@ -143,7 +143,7 @@ const RetenoPluginFunctions = {
           inAppMessagesPauseBehaviour?: 'SKIP_IN_APPS' | 'POSTPONE_IN_APPS',
           isAutomaticScreenReportingEnabled?: boolean,
           isDebugMode?: boolean,
-          sessionDurationSeconds?: number, // Android 2.9.4+, iOS 2.7.0+
+          sessionDurationSeconds?: number, // Android 2.9.6+, iOS 2.7.2+
           lifecycleTrackingOptions?: {
             appLifecycleEnabled?: boolean,
             foregroundLifecycleEnabled?: boolean,
@@ -525,6 +525,44 @@ const RetenoPluginFunctions = {
     return __callWithAutoInit('updateDefaultNotificationChannel', [config], success, error);
   },
 
+  /*
+        config: NotificationGroupingRule | null
+        { payloadKey: string } groups by a value from the push payload.
+        { groupId: string } assigns every Reteno notification to a constant group.
+        Set showSummary: true to let the plugin maintain a group-summary notification.
+        Passing null disables grouping.
+        Android only.
+        */
+  setNotificationGroupingRule: function (arg0, success, error) {
+    // Accept either `config` or legacy `[config]`.
+    const config = Array.isArray(arg0) ? arg0[0] : arg0;
+    if (config === null) {
+      return __callWithExec('setNotificationGroupingRule', [null], success, error);
+    }
+    if (!config || typeof config !== 'object') {
+      return Promise.reject(
+        new Error('Invalid argument: expected null or an object with payloadKey or groupId')
+      );
+    }
+
+    const payloadKey = typeof config.payloadKey === 'string' ? config.payloadKey.trim() : '';
+    const groupId = typeof config.groupId === 'string' ? config.groupId.trim() : '';
+    if (config.showSummary !== undefined && typeof config.showSummary !== 'boolean') {
+      return Promise.reject(new Error('Invalid argument: showSummary must be a boolean'));
+    }
+    if (!!payloadKey === !!groupId) {
+      return Promise.reject(
+        new Error('Invalid argument: provide exactly one of payloadKey or groupId')
+      );
+    }
+
+    const normalizedConfig = payloadKey ? { payloadKey } : { groupId };
+    if (config.showSummary === true) {
+      normalizedConfig.showSummary = true;
+    }
+    return __callWithExec('setNotificationGroupingRule', [normalizedConfig], success, error);
+  },
+
   /*
         payload: GetAppInboxMessagesPayload
         {