react-native-insider 8.1.0 → 9.0.0

package/android/src/main/java/com/useinsider/react/RNInsiderModule.java

@@ -7,13 +7,16 @@ import android.os.Looper;
 import android.content.Intent;
 import android.net.Uri;
 
+import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.Callback;
 import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContext;
 import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.react.bridge.ReactMethod;
 import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeMap;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
 import com.google.firebase.messaging.RemoteMessage;
 import com.useinsider.insider.Insider;
@@ -31,10 +34,12 @@ import com.useinsider.insider.RecommendationEngine;
 import com.useinsider.insiderhybrid.InsiderHybrid;
 import com.useinsider.insiderhybrid.constants.InsiderHybridMethods;
 import com.useinsider.insider.InsiderIDListener;
+import com.useinsider.insider.InsiderEventListener;
 
 import org.json.JSONArray;
 import org.json.JSONObject;
 
+import java.lang.reflect.Method;
 import java.util.Date;
 import java.util.HashMap;
 import java.util.Map;
@@ -48,6 +53,11 @@ public class RNInsiderModule extends ReactContextBaseJavaModule {
 
     private InsiderIDListener insiderIDListener;
 
+    // Written on the NativeModules thread, read again from the posted main-looper Runnable
+    // whose identity check decides whether to register. volatile makes that read's visibility
+    // explicit rather than relying on the happens-before edge Handler.post happens to give us.
+    private volatile InsiderEventListener insiderEventListener;
+
     public RNInsiderModule(ReactApplicationContext reactContext) {
         super(reactContext);
         this.reactContext = reactContext;
@@ -58,40 +68,69 @@ public class RNInsiderModule extends ReactContextBaseJavaModule {
         return "RNInsider";
     }
 
-    @ReactMethod
-    public void setName(String name) {
+    private static final Method emitDeviceEventMethod = resolveEmitDeviceEvent();
+
+    private static Method resolveEmitDeviceEvent() {
         try {
-            Insider.Instance.getCurrentUser().setName(name);
-        } catch (Exception e) {
-            Insider.Instance.putException(e);
+            return ReactContext.class.getMethod("emitDeviceEvent", String.class, Object.class);
+        } catch (NoSuchMethodException e) {
+            return null;
+        }
+    }
+
+    private void emitDeviceEventCompat(String eventName, Object payload) {
+        ReactApplicationContext context = getReactApplicationContext();
+
+        if (emitDeviceEventMethod != null) {
+            try {
+                emitDeviceEventMethod.invoke(context, eventName, payload);
+                return;
+            } catch (Exception e) {
+                Insider.Instance.putException(e);
+                return;
+            }
+        }
+
+        DeviceEventManagerModule.RCTDeviceEventEmitter emitter =
+                context.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class);
+
+        if (emitter != null) {
+            emitter.emit(eventName, payload);
         }
     }
 
     @ReactMethod
-    public void init(final String partnerName, final String sdkVersion) {
+    public void setName(String name) {
+        Insider.Instance.getCurrentUser().setName(name);
+    }
+
+    @ReactMethod
+    public void init(final String partnerName, final String sdkVersion, final String appIdentifier) {
         try {
             if (Insider.Instance.isSDKInitialized()) {
                 return;
             }
+            final String app = resolveAppIdentifier(appIdentifier);
             new Handler(Looper.getMainLooper()).post(new Runnable() {
                 @Override
                 public void run() {
                     Insider.Instance.registerInsiderCallback(new InsiderCallback() {
-                        DeviceEventManagerModule.RCTDeviceEventEmitter emitter = getReactApplicationContext()
-                                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class);
-
                         @Override
                         public void doAction(JSONObject jsonObject, InsiderCallbackType insiderCallbackType) {
                             try {
                                 WritableMap callbackData = RNUtils.convertJSONObjectToMap(jsonObject);
-                                emitter.emit(insiderCallbackType.name(), callbackData);
+                                emitDeviceEventCompat(insiderCallbackType.name(), callbackData);
                             } catch (Exception e) {
                                 Insider.Instance.putException(e);
                             }
                         }
                     });
 
-                    Insider.Instance.init(((Application) reactContext.getApplicationContext()), partnerName);
+                    if (app != null) {
+                        Insider.Instance.init(((Application) reactContext.getApplicationContext()), partnerName, app);
+                    } else {
+                        Insider.Instance.init(((Application) reactContext.getApplicationContext()), partnerName);
+                    }
                     Insider.Instance.setSDKType("react-native");
                     Insider.Instance.setHybridSDKVersion(sdkVersion);
 
@@ -109,22 +148,18 @@ public class RNInsiderModule extends ReactContextBaseJavaModule {
         }
     }
 
+    private String resolveAppIdentifier(String app) {
+        return app != null && !app.isEmpty() ? app : null;
+    }
+
     @ReactMethod
     public void reinitWithPartnerName(String partnerName) {
-        try {
-            Insider.Instance.reinitWithPartnerName(partnerName);
-        } catch (Exception e) {
-            Insider.Instance.putException(e);
-        }
+        Insider.Instance.reinitWithPartnerName(partnerName);
     }
 
     @ReactMethod
     public void setCustomEndpoint(String endpoint) {
-        try {
-            Insider.Instance.setCustomEndpoint(endpoint);
-        } catch (Exception e) {
-            Insider.Instance.putException(e);
-        }
+        Insider.Instance.setCustomEndpoint(endpoint);
     }
 
     @ReactMethod
@@ -138,11 +173,7 @@ public class RNInsiderModule extends ReactContextBaseJavaModule {
 
     @ReactMethod
     public void setGender(int gender) {
-        try {
-            InsiderHybrid.setGender(gender);
-        } catch (Exception e) {
-            Insider.Instance.putException(e);
-        }
+        InsiderHybrid.setGender(gender);
     }
 
     @ReactMethod
@@ -159,116 +190,73 @@ public class RNInsiderModule extends ReactContextBaseJavaModule {
 
     @ReactMethod
     public void setSurname(String surname) {
-        try {
-            Insider.Instance.getCurrentUser().setSurname(surname);
-        } catch (Exception e) {
-            Insider.Instance.putException(e);
-        }
+        Insider.Instance.getCurrentUser().setSurname(surname);
     }
 
     @ReactMethod
     public void setAge(int age) {
-        try {
-            Insider.Instance.getCurrentUser().setAge(age);
-        } catch (Exception e) {
-            Insider.Instance.putException(e);
-        }
+        Insider.Instance.getCurrentUser().setAge(age);
     }
 
     @ReactMethod
     public void setLanguage(String language) {
-        try {
-            Insider.Instance.getCurrentUser().setLanguage(language);
-        } catch (Exception e) {
-            Insider.Instance.putException(e);
-        }
+        Insider.Instance.getCurrentUser().setLanguage(language);
     }
 
     @ReactMethod
     public void setLocale(String locale) {
-        try {
-            Insider.Instance.getCurrentUser().setLocale(locale);
-        } catch (Exception e) {
-            Insider.Instance.putException(e);
-        }
+        Insider.Instance.getCurrentUser().setLocale(locale);
     }
 
     @ReactMethod
     public void setFacebookID(String facebookID) {
-        try {
-            Insider.Instance.getCurrentUser().setFacebookID(facebookID);
-        } catch (Exception e) {
-            Insider.Instance.putException(e);
-        }
+        Insider.Instance.getCurrentUser().setFacebookID(facebookID);
     }
 
     @ReactMethod
     public void setTwitterID(String twitterID) {
-        try {
-            Insider.Instance.getCurrentUser().setTwitterID(twitterID);
-        } catch (Exception e) {
-            Insider.Instance.putException(e);
-        }
+        Insider.Instance.getCurrentUser().setTwitterID(twitterID);
     }
 
     @ReactMethod
     public void setEmailOptin(boolean emailOptin) {
-        try {
-            Insider.Instance.getCurrentUser().setEmailOptin(emailOptin);
-        } catch (Exception e) {
-            Insider.Instance.putException(e);
-        }
+        Insider.Instance.getCurrentUser().setEmailOptin(emailOptin);
     }
 
     @ReactMethod
     public void setEmail(String email) {
-        try {
-            Insider.Instance.getCurrentUser().setEmail(email);
-        } catch (Exception e) {
-            Insider.Instance.putException(e);
-        }
+        Insider.Instance.getCurrentUser().setEmail(email);
     }
 
     @ReactMethod
     public void setSMSOptin(boolean smsOptin) {
-        try {
-            Insider.Instance.getCurrentUser().setSMSOptin(smsOptin);
-        } catch (Exception e) {
-            Insider.Instance.putException(e);
-        }
+        Insider.Instance.getCurrentUser().setSMSOptin(smsOptin);
     }
 
     @ReactMethod
     public void setPhoneNumber(String phoneNumber) {
-        try {
-            Insider.Instance.getCurrentUser().setPhoneNumber(phoneNumber);
-        } catch (Exception e) {
-            Insider.Instance.putException(e);
-        }
+        Insider.Instance.getCurrentUser().setPhoneNumber(phoneNumber);
     }
 
     @ReactMethod
     public void setPushOptin(boolean pushOptin) {
-        try {
-            Insider.Instance.getCurrentUser().setPushOptin(pushOptin);
-        } catch (Exception e) {
-            Insider.Instance.putException(e);
-        }
+        Insider.Instance.getCurrentUser().setPushOptin(pushOptin);
     }
 
     @ReactMethod
     public void setLocationOptin(boolean locationOptin) {
-        try {
-            Insider.Instance.getCurrentUser().setLocationOptin(locationOptin);
-        } catch (Exception e) {
-            Insider.Instance.putException(e);
-        }
+        Insider.Instance.getCurrentUser().setLocationOptin(locationOptin);
     }
 
     @ReactMethod
     public void setWhatsappOptin(boolean whatsappOptin) {
+        Insider.Instance.getCurrentUser().setWhatsappOptin(whatsappOptin);
+    }
+
+    @ReactMethod
+    public void setPromotionalOptin(boolean promotionalOptin) {
         try {
-            Insider.Instance.getCurrentUser().setWhatsappOptin(whatsappOptin);
+            Insider.Instance.getCurrentUser().setPromotionalOptin(promotionalOptin);
         } catch (Exception e) {
             Insider.Instance.putException(e);
         }
@@ -276,13 +264,9 @@ public class RNInsiderModule extends ReactContextBaseJavaModule {
 
     @ReactMethod
     public void login(ReadableMap identifiers) {
-        try {
-            InsiderIdentifiers setIdentifiers = setIdentifiers(identifiers);
+        InsiderIdentifiers setIdentifiers = setIdentifiers(identifiers);
 
-            Insider.Instance.getCurrentUser().login(setIdentifiers);
-        } catch (Exception e) {
-            Insider.Instance.putException(e);
-        }
+        Insider.Instance.getCurrentUser().login(setIdentifiers);
     }
 
     @ReactMethod
@@ -302,6 +286,7 @@ public class RNInsiderModule extends ReactContextBaseJavaModule {
             });
         } catch (Exception e) {
             Insider.Instance.putException(e);
+            RNInsiderIDResult.invoke((String) null);
         }
     }
 
@@ -335,11 +320,7 @@ public class RNInsiderModule extends ReactContextBaseJavaModule {
 
     @ReactMethod
     public void logout() {
-        try {
-            Insider.Instance.getCurrentUser().logout();
-        } catch (Exception e) {
-            Insider.Instance.putException(e);
-        }
+        Insider.Instance.getCurrentUser().logout();
     }
 
     @ReactMethod
@@ -363,6 +344,9 @@ public class RNInsiderModule extends ReactContextBaseJavaModule {
             }
         } catch (Exception e) {
             Insider.Instance.putException(e);
+            if (insiderIDResult != null) {
+                insiderIDResult.invoke((String) null);
+            }
         }
     }
 
@@ -381,38 +365,22 @@ public class RNInsiderModule extends ReactContextBaseJavaModule {
 
     @ReactMethod
     public void setCustomAttributeWithString(String key, String value) {
-        try {
-            Insider.Instance.getCurrentUser().setCustomAttributeWithString(key, value);
-        } catch (Exception e) {
-            Insider.Instance.putException(e);
-        }
+        Insider.Instance.getCurrentUser().setCustomAttributeWithString(key, value);
     }
 
     @ReactMethod
     public void setCustomAttributeWithInt(String key, int value) {
-        try {
-            Insider.Instance.getCurrentUser().setCustomAttributeWithInt(key, value);
-        } catch (Exception e) {
-            Insider.Instance.putException(e);
-        }
+        Insider.Instance.getCurrentUser().setCustomAttributeWithInt(key, value);
     }
 
     @ReactMethod
     public void setCustomAttributeWithDouble(String key, double value) {
-        try {
-            Insider.Instance.getCurrentUser().setCustomAttributeWithDouble(key, value);
-        } catch (Exception e) {
-            Insider.Instance.putException(e);
-        }
+        Insider.Instance.getCurrentUser().setCustomAttributeWithDouble(key, value);
     }
 
     @ReactMethod
     public void setCustomAttributeWithBoolean(String key, boolean value) {
-        try {
-            Insider.Instance.getCurrentUser().setCustomAttributeWithBoolean(key, value);
-        } catch (Exception e) {
-            Insider.Instance.putException(e);
-        }
+        Insider.Instance.getCurrentUser().setCustomAttributeWithBoolean(key, value);
     }
 
     @ReactMethod
@@ -438,11 +406,7 @@ public class RNInsiderModule extends ReactContextBaseJavaModule {
 
     @ReactMethod
     public void unsetCustomAttribute(String key) {
-        try {
-            Insider.Instance.getCurrentUser().unsetCustomAttribute(key);
-        } catch (Exception e) {
-            Insider.Instance.putException(e);
-        }
+        Insider.Instance.getCurrentUser().unsetCustomAttribute(key);
     }
 
     @ReactMethod
@@ -450,22 +414,14 @@ public class RNInsiderModule extends ReactContextBaseJavaModule {
         new Handler(Looper.getMainLooper()).post(new Runnable() {
             @Override
             public void run() {
-                try {
-                    Insider.Instance.setGDPRConsent(gdprConsent);
-                } catch (Exception e) {
-                    Insider.Instance.putException(e);
-                }
+                Insider.Instance.setGDPRConsent(gdprConsent);
             }
         });
     }
 
     @ReactMethod
     public void setMobileAppAccess(final boolean mobileAppAccess) {
-        try {
-            Insider.Instance.setMobileAppAccess(mobileAppAccess);
-        } catch (Exception e) {
-            Insider.Instance.putException(e);
-        }
+        Insider.Instance.setMobileAppAccess(mobileAppAccess);
     }
 
     @ReactMethod
@@ -580,11 +536,11 @@ public class RNInsiderModule extends ReactContextBaseJavaModule {
 
     @ReactMethod
     public void getMessageCenterData(int limit, String startDate, String endDate, final Callback messageCenterCallback) {
-        // React Native's bridge does not support long type directly, so we use String to pass epoch time.
-        long startDateEpoch = Long.parseLong(startDate);
-        long endDateEpoch = Long.parseLong(endDate);
-
         try {
+            // React Native's bridge does not support long type directly, so we use String to pass epoch time.
+            long startDateEpoch = Long.parseLong(startDate);
+            long endDateEpoch = Long.parseLong(endDate);
+
             InsiderHybrid.getMessageCenterData(limit, startDateEpoch, endDateEpoch, new MessageCenterData() {
                 @Override
                 public void loadMessageCenterData(JSONArray messageCenterData) {
@@ -597,15 +553,16 @@ public class RNInsiderModule extends ReactContextBaseJavaModule {
             });
         } catch (Exception e) {
             Insider.Instance.putException(e);
+            messageCenterCallback.invoke("[]");
         }
     }
 
     @ReactMethod
     public void getMessageCenterDataWithIdentifiers(int limit, String startDate, String endDate, ReadableMap identifiers, final Callback messageCenterCallback) {
-        long startDateEpoch = Long.parseLong(startDate);
-        long endDateEpoch = Long.parseLong(endDate);
-
         try {
+            long startDateEpoch = Long.parseLong(startDate);
+            long endDateEpoch = Long.parseLong(endDate);
+
             Insider.Instance.getMessageCenterData(
                     limit,
                     new Date(startDateEpoch),
@@ -623,6 +580,7 @@ public class RNInsiderModule extends ReactContextBaseJavaModule {
                     });
         } catch (Exception e) {
             Insider.Instance.putException(e);
+            messageCenterCallback.invoke("[]");
         }
     }
 
@@ -643,6 +601,7 @@ public class RNInsiderModule extends ReactContextBaseJavaModule {
                     });
         } catch (Exception e) {
             Insider.Instance.putException(e);
+            smartRecommendation.invoke(Arguments.createMap());
         }
     }
 
@@ -664,6 +623,7 @@ public class RNInsiderModule extends ReactContextBaseJavaModule {
                     });
         } catch (Exception e) {
             Insider.Instance.putException(e);
+            callback.invoke(Arguments.createMap());
         }
     }
 
@@ -685,6 +645,7 @@ public class RNInsiderModule extends ReactContextBaseJavaModule {
                     });
         } catch (Exception e) {
             Insider.Instance.putException(e);
+            callback.invoke(Arguments.createMap());
         }
     }
 
@@ -758,6 +719,15 @@ public class RNInsiderModule extends ReactContextBaseJavaModule {
         }
     }
 
+    @ReactMethod
+    public void markContentOptimizerAsSeen(String variableName) {
+        try {
+            Insider.Instance.markContentOptimizerAsSeen(variableName);
+        } catch (Exception e) {
+            Insider.Instance.putException(e);
+        }
+    }
+
 
     @ReactMethod
     public void visitHomePage(ReadableArray customParameters) {
@@ -863,11 +833,7 @@ public class RNInsiderModule extends ReactContextBaseJavaModule {
         new Handler(Looper.getMainLooper()).post(new Runnable() {
             @Override
             public void run() {
-                try {
-                    Insider.Instance.startTrackingGeofence();
-                } catch (Exception e) {
-                    Insider.Instance.putException(e);
-                }
+                Insider.Instance.startTrackingGeofence();
             }
         });
     }
@@ -944,12 +910,7 @@ public class RNInsiderModule extends ReactContextBaseJavaModule {
 
     @ReactMethod
     public void putErrorLog(String exception) {
-        try {
-            Exception exceptionObject = new Exception(exception);
-            Insider.Instance.putException(exceptionObject);
-        } catch (Exception ignored) {
-
-        }
+        Insider.Instance.putException(new Exception(exception));
     }
 
     @ReactMethod
@@ -966,11 +927,7 @@ public class RNInsiderModule extends ReactContextBaseJavaModule {
         new Handler(Looper.getMainLooper()).post(new Runnable() {
             @Override
             public void run() {
-                try {
-                    Insider.Instance.enableLocationCollection(consentStatus);
-                } catch (Exception e) {
-                    Insider.Instance.putException(e);
-                }
+                Insider.Instance.enableLocationCollection(consentStatus);
             }
         });
     }
@@ -980,11 +937,7 @@ public class RNInsiderModule extends ReactContextBaseJavaModule {
         new Handler(Looper.getMainLooper()).post(new Runnable() {
             @Override
             public void run() {
-                try {
-                    Insider.Instance.enableIpCollection(consentStatus);
-                } catch (Exception e) {
-                    Insider.Instance.putException(e);
-                }
+                Insider.Instance.enableIpCollection(consentStatus);
             }
         });
     }
@@ -994,11 +947,7 @@ public class RNInsiderModule extends ReactContextBaseJavaModule {
         new Handler(Looper.getMainLooper()).post(new Runnable() {
             @Override
             public void run() {
-                try {
-                    Insider.Instance.enableCarrierCollection(consentStatus);
-                } catch (Exception e) {
-                    Insider.Instance.putException(e);
-                }
+                Insider.Instance.enableCarrierCollection(consentStatus);
             }
         });
     }
@@ -1068,12 +1017,9 @@ public class RNInsiderModule extends ReactContextBaseJavaModule {
                     @Override
                     public void run() {
                         insiderIDListener = new InsiderIDListener() {
-                            DeviceEventManagerModule.RCTDeviceEventEmitter emitter = getReactApplicationContext()
-                                    .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class);
-
                             @Override
                             public void onUpdated(String insiderID) {
-                                emitter.emit("INSIDER_ID_LISTENER", insiderID);
+                                emitDeviceEventCompat("INSIDER_ID_LISTENER", insiderID);
                             }
                         };
 
@@ -1087,24 +1033,142 @@ public class RNInsiderModule extends ReactContextBaseJavaModule {
         }
     }
 
+    /**
+     * Registers a single {@link InsiderEventListener} that forwards every recorded event to
+     * JS as {@code INSIDER_EVENT_RECORDED}. The JS layer fans out to its own subscribers, so
+     * this bridge only ever needs one native observer — the null-guard makes repeat calls
+     * idempotent.
+     *
+     * <p>Note the SDK delivers on its own background thread; only the REGISTRATION is hopped
+     * onto the main looper (matching {@link #registerInsiderIDListener()}). The
+     * {@code parameters} map handed to us is unmodifiable, so we only read from it.
+     *
+     * <p>{@code Insider.Instance.events()} returns a no-op instance before SDK init, so it is
+     * resolved fresh here at registration time rather than cached in a field.
+     */
     @ReactMethod
-    public void disableInAppMessages() {
+    public void registerInsiderEventListener() {
         try {
-            Insider.Instance.disableInAppMessages();
+            // The guard and the field assignment BOTH happen synchronously on the calling
+            // thread. Deferring the assignment into the posted Runnable would let the guard
+            // race unregisterInsiderEventListener(), which reads the field synchronously:
+            // a subscribe-then-immediate-unsubscribe would see null, no-op, and then leave
+            // the Runnable to register an observer JS believes is gone; a subscribe burst
+            // would see null twice and addObserver() twice, double-delivering every event.
+            // Only the SDK call itself is hopped onto the main looper.
+            if (insiderEventListener != null) return;
+
+            final InsiderEventListener listener = new InsiderEventListener() {
+                @Override
+                public void onEventRecorded(String name, Map<String, Object> parameters, long timestamp) {
+                    try {
+                        WritableMap payload = new WritableNativeMap();
+                        payload.putString("name", name);
+                        payload.putMap("parameters", RNUtils.convertObjectMapToWritableMap(parameters));
+                        // Passed through in WHOLE SECONDS, matching the native SDK.
+                        // JS must do `new Date(timestamp * 1000)`.
+                        payload.putDouble("timestamp", (double) timestamp);
+
+                        // THREADING (matches the note in iOS RNInsider.m — do not
+                        // re-litigate): this runs on the SDK's listener thread and
+                        // needs no manual hop. RCTDeviceEventEmitter.emit is a
+                        // JS-module proxy call; the bridge enqueues it onto the JS
+                        // thread itself, in order, so emitting from here is safe.
+                        //
+                        // The emitter is resolved per emit rather than cached: a dev
+                        // reload or Activity recreation replaces the catalyst instance,
+                        // and a cached proxy would then target a dead one and silently
+                        // stop delivering. emitDeviceEventCompat also covers bridgeless,
+                        // where getJSModule may return null.
+                        emitDeviceEventCompat("INSIDER_EVENT_RECORDED", payload);
+                    } catch (Exception e) {
+                        Insider.Instance.putException(e);
+                    }
+                }
+            };
+
+            insiderEventListener = listener;
+
+            new Handler(Looper.getMainLooper()).post(new Runnable() {
+                @Override
+                public void run() {
+                    try {
+                        // An unregister may have landed while this was queued. Only register
+                        // if this listener is still the current one, so we never revive an
+                        // observer the JS side has already dropped.
+                        if (insiderEventListener != listener) return;
+
+                        Insider.Instance.events().addObserver(listener);
+                    } catch (Exception e) {
+                        if (insiderEventListener == listener) insiderEventListener = null;
+                        Insider.Instance.putException(e);
+                    }
+                }
+            });
         } catch (Exception e) {
             Insider.Instance.putException(e);
         }
     }
 
+    /**
+     * Removes the observer registered by {@link #registerInsiderEventListener()}. Android
+     * holds listeners STRONGLY, so this teardown is required to avoid leaking the listener
+     * for the lifetime of the process.
+     *
+     * <p>The field is cleared synchronously so a register that is still queued sees the
+     * identity change and cancels itself. Both methods post to the same looper, so the SDK
+     * add/remove calls also stay in submission order.
+     */
     @ReactMethod
-    public void enableInAppMessages() {
+    public void unregisterInsiderEventListener() {
         try {
-            Insider.Instance.enableInAppMessages();
+            if (insiderEventListener != null) {
+                final InsiderEventListener listenerToRemove = insiderEventListener;
+                insiderEventListener = null;
+
+                new Handler(Looper.getMainLooper()).post(new Runnable() {
+                    @Override
+                    public void run() {
+                        try {
+                            Insider.Instance.events().removeObserver(listenerToRemove);
+                        } catch (Exception e) {
+                            Insider.Instance.putException(e);
+                        }
+                    }
+                });
+            }
         } catch (Exception e) {
             Insider.Instance.putException(e);
         }
     }
 
+    /**
+     * Tears the event observer down when the bridge itself goes away — a dev reload or an
+     * Activity recreation destroys the catalyst instance without JS ever getting to call
+     * {@link #unregisterInsiderEventListener()}.
+     *
+     * <p>This matters because Android holds observers STRONGLY: without this the listener
+     * survives the bridge, keeps the dead {@code ReactApplicationContext} alive through it,
+     * and every subsequent reload stacks another observer onto the SDK. The delegation keeps
+     * the teardown sequence (synchronous field clear, then the main-looper removeObserver) in
+     * one place rather than duplicating it here.
+     */
+    @Override
+    public void invalidate() {
+        unregisterInsiderEventListener();
+        super.invalidate();
+    }
+
+    @ReactMethod
+    public void disableInAppMessages() {
+        Insider.Instance.disableInAppMessages();
+    }
+
+    @ReactMethod
+    public void enableInAppMessages() {
+        Insider.Instance.enableInAppMessages();
+    }
+
     @ReactMethod
     public void getAppCardsCampaigns(final Callback callback) {
         try {