cordova-plugin-reteno 2.0.4 → 2.2.0

package/docs/ios.md

@@ -68,17 +68,16 @@ 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
 ```
 
-
 ## Add Notification Content Extension (NCE) — Images Carousel
 
 The Notification Content Extension is required for rich push notifications with an **Images Carousel**.
@@ -86,7 +85,7 @@ It provides the `UNNotificationContentExtension` entry point that renders a cust
 
 Official guide: https://docs.reteno.com/reference/ios-images-carousel
 
-### Create the extension target *(manual Xcode step)*
+### Create the extension target _(manual Xcode step)_
 
 In Xcode: **File → New → Target → Notification Content Extension**. Name it `NotificationContentExtension`.
 
@@ -130,7 +129,7 @@ Open `NotificationContentExtension/Info.plist` as source code and replace the `N
 
 Make sure the NCE **Deployment Target** in Xcode matches the main app target (iOS 15.0+). A mismatch is the most common reason carousel images fail to display.
 
-### Embed App Extensions — Copy only when installing *(manual Xcode step)*
+### Embed App Extensions — Copy only when installing _(manual Xcode step)_
 
 > **This step must be done manually in Xcode** — it cannot be automated.
 > Official guide (Troubleshooting → "Turn off Copy Only when Installing"): https://docs.reteno.com/reference/ios-images-carousel
@@ -187,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
 ```
@@ -307,6 +306,7 @@ If your app calls `FirebaseApp.configure()` without this file, Firebase will cra
 Nothing to do. Firebase iOS SDK uses **method swizzling** by default — it automatically intercepts `didRegisterForRemoteNotificationsWithDeviceToken` and forwards the APNS token to Firebase without any AppDelegate code.
 
 When `IOS_DEVICE_TOKEN_HANDLING_MODE` is set to `manual`, the plugin:
+
 1. Calls `FirebaseApp.configure()` automatically on `init()` if not already called and `GoogleService-Info.plist` is present.
 2. Subscribes to FCM token updates and forwards them to Reteno once Firebase is configured.
 
@@ -381,7 +381,7 @@ await RetenoPlugin.init({
 });
 
 // Runtime pause/resume
-await RetenoPlugin.pauseInAppMessages(true);  // pause
+await RetenoPlugin.pauseInAppMessages(true); // pause
 await RetenoPlugin.pauseInAppMessages(false); // resume
 ```
 
@@ -403,7 +403,7 @@ Set presentation options for foreground notifications:
 ```js
 await RetenoPlugin.setWillPresentNotificationOptions({
   options: ['badge', 'sound', 'banner'],
-  emitEvent: true
+  emitEvent: true,
 });
 ```
 
@@ -414,7 +414,7 @@ Enable a response handler for notification taps:
 ```js
 await RetenoPlugin.setDidReceiveNotificationResponseHandler({
   enabled: true,
-  emitEvent: true
+  emitEvent: true,
 });
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cordova-plugin-reteno",
-  "version": "2.0.4",
+  "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.0.4" 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.0" />
+      <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.4'
+def retenoFcmVersion = '2.10.1'
 
 def firebaseMessagingVersion = '23.1.0'