Merge branch 'staging' into fix452/strict_mode_content

Author: arifBurakDemiray

CHANGELOG.md

@@ -1,7 +1,11 @@
 ## XX.XX.XX
+* Added gradle configuration cache support to upload symbols plugin.
 * Improved user properties auto-save conditions to flush event queue with every user property call.
 
 * Mitigated StrictMode `IncorrectContextUseViolation` warnings logged when the SDK retrieved device display metrics and constructed the content overlay view from a non-UI context.
+* Mitigated an issue where content overlays and feedback widgets prevented keyboard input on the underlying activity's text fields while displayed.
+* Mitigated a memory retention issue where content overlays and feedback widgets could be briefly held in memory after closing, surfacing under repeated open/close cycles.
+* Mitigated a memory leak where the content overlay retained the activity it was first opened in across subsequent activity transitions.
 
 ## 26.1.2
 * Added `CountlyInitProvider` ContentProvider to register activity lifecycle callbacks before `Application.onCreate()`. This ensures the SDK captures the current activity in single-activity frameworks (Flutter, React Native) and apps with deferred initialization.

sdk/src/androidTest/java/ly/count/android/sdk/ContentOverlayViewTests.java

@@ -790,4 +790,48 @@ public void contentUrlAction_noQueryParams_returnsFalse() {
             Assert.assertFalse(overlay.contentUrlAction(url, overlay.webView));
         });
     }
+
+    // ===================== Memory leak prevention (issue #556) =====================
+
+    /**
+     * Structural invariant: the overlay's View.mContext must be the Application, not the
+     * constructing activity. This is what allows the overlay to outlive activity transitions
+     * without leaking the activity it was first opened in.
+     *
+     * Regression guard: if anyone changes the constructor's super(...) call back to the
+     * activity, this test will fail and surface the leak before users do.
+     */
+    @Test
+    public void constructor_usesApplicationContext_notActivity() {
+        withActivity(activity -> {
+            overlay = createOverlay(activity);
+            Assert.assertNotSame(
+                "ContentOverlayView.mContext must not be the constructing Activity — "
+                    + "View.mContext can never be swapped, so binding it to an Activity leaks "
+                    + "that Activity for the lifetime of the overlay.",
+                activity, overlay.getContext());
+            Assert.assertSame(
+                "ContentOverlayView.mContext must be the Application context.",
+                activity.getApplicationContext(), overlay.getContext());
+        });
+    }
+
+    /**
+     * Same invariant for the embedded WebView. Even with the wrapper View using App context,
+     * a WebView constructed with Activity context would still pin the constructing activity
+     * via its own mContext.
+     */
+    @Test
+    public void webView_usesApplicationContext_notActivity() {
+        withActivity(activity -> {
+            overlay = createOverlay(activity);
+            Assert.assertNotNull("WebView should be created during construction", overlay.webView);
+            Assert.assertNotSame(
+                "ContentOverlayView's WebView.mContext must not be the constructing Activity.",
+                activity, overlay.webView.getContext());
+            Assert.assertSame(
+                "ContentOverlayView's WebView.mContext must be the Application context.",
+                activity.getApplicationContext(), overlay.webView.getContext());
+        });
+    }
 }

sdk/src/androidTest/java/ly/count/android/sdk/ModuleContentTests.java

@@ -1,5 +1,6 @@
 package ly.count.android.sdk;
 
+import android.app.Activity;
 import androidx.test.ext.junit.runners.AndroidJUnit4;
 import java.util.ArrayList;
 import java.util.List;
@@ -11,6 +12,8 @@
 import org.junit.Test;
 import org.junit.runner.RunWith;
 
+import static org.mockito.Mockito.mock;
+
 @RunWith(AndroidJUnit4.class)
 public class ModuleContentTests {
 
@@ -68,6 +71,12 @@ private void setIsCurrentlyInContentZone(ModuleContent module, boolean value) th
         field.set(module, value);
     }
 
+    private Activity getCurrentActivity(ModuleContent module) throws Exception {
+        java.lang.reflect.Field field = ModuleContent.class.getDeclaredField("currentActivity");
+        field.setAccessible(true);
+        return (Activity) field.get(module);
+    }
+
     // ======== previewContent public API tests ========
 
     /**
@@ -158,4 +167,92 @@ public void validateResponse() throws JSONException {
         valid.put("html", "<html></html>");
         Assert.assertTrue(mc.validateResponse(valid));
     }
+
+    // ======== Activity reference / leak prevention tests (issue #556) ========
+
+    /**
+     * onActivityDestroyed must null out currentActivity when the destroyed activity
+     * is the one currently tracked. This is the core leak fix.
+     */
+    @Test
+    public void onActivityDestroyed_clearsCurrentActivity_whenIdentityMatches() throws Exception {
+        Countly countly = initWithConsent(true);
+        ModuleContent mc = countly.moduleContent;
+
+        Activity act = mock(Activity.class);
+        mc.onActivityStarted(act, 1);
+        Assert.assertSame(act, getCurrentActivity(mc));
+
+        mc.onActivityDestroyed(act);
+        Assert.assertNull(getCurrentActivity(mc));
+    }
+
+    /**
+     * Destroying an activity other than the currently tracked one must NOT clear the field.
+     * This protects against losing the active activity reference when an old, already-replaced
+     * activity is finally destroyed.
+     */
+    @Test
+    public void onActivityDestroyed_doesNotClear_whenDifferentActivity() throws Exception {
+        Countly countly = initWithConsent(true);
+        ModuleContent mc = countly.moduleContent;
+
+        Activity tracked = mock(Activity.class);
+        Activity unrelated = mock(Activity.class);
+        mc.onActivityStarted(tracked, 1);
+
+        mc.onActivityDestroyed(unrelated);
+        Assert.assertSame(tracked, getCurrentActivity(mc));
+    }
+
+    /**
+     * Rotation race regression: when onActivityStarted for the new activity fires before
+     * onActivityDestroyed for the old one, destroying the old activity must not wipe out
+     * the new tracked activity.
+     */
+    @Test
+    public void onActivityDestroyed_doesNotClearNewerActivity_afterRotationRace() throws Exception {
+        Countly countly = initWithConsent(true);
+        ModuleContent mc = countly.moduleContent;
+
+        Activity oldAct = mock(Activity.class);
+        Activity newAct = mock(Activity.class);
+
+        mc.onActivityStarted(oldAct, 1);
+        mc.onActivityStarted(newAct, 2);
+        Assert.assertSame(newAct, getCurrentActivity(mc));
+
+        // Old activity is finally destroyed after the new one has already taken over.
+        mc.onActivityDestroyed(oldAct);
+        Assert.assertSame(newAct, getCurrentActivity(mc));
+    }
+
+    /**
+     * onActivityDestroyed must not throw when no activity has been tracked yet.
+     */
+    @Test
+    public void onActivityDestroyed_isSafe_whenNoActivityTracked() throws Exception {
+        Countly countly = initWithConsent(true);
+        ModuleContent mc = countly.moduleContent;
+
+        Activity stray = mock(Activity.class);
+        mc.onActivityDestroyed(stray);
+        Assert.assertNull(getCurrentActivity(mc));
+    }
+
+    /**
+     * The seeded activity path (onInitialActivitySeeded) must also be cleared on destroy.
+     */
+    @Test
+    public void onActivityDestroyed_clearsSeededActivity() throws Exception {
+        Countly countly = initWithConsent(true);
+        ModuleContent mc = countly.moduleContent;
+
+        Activity seeded = mock(Activity.class);
+        mc.onInitialActivitySeeded(seeded);
+        Assert.assertSame(seeded, getCurrentActivity(mc));
+
+        mc.onActivityDestroyed(seeded);
+        Assert.assertNull(getCurrentActivity(mc));
+    }
 }

sdk/src/androidTest/java/ly/count/android/sdk/ModuleFeedbackTests.java

@@ -1,5 +1,6 @@
 package ly.count.android.sdk;
 
+import android.app.Activity;
 import androidx.annotation.NonNull;
 import androidx.test.core.app.ApplicationProvider;
 import androidx.test.ext.junit.runners.AndroidJUnit4;
@@ -694,4 +695,90 @@ private void fillFeedbackWidgetSegmentationParams(Map<String, Object> segmentati
         segmentation.put("app_version", "1.0");
         segmentation.put("widget_id", widgetId);
     }
+
+    private Activity getCurrentActivity(ModuleFeedback module) throws Exception {
+        java.lang.reflect.Field field = ModuleFeedback.class.getDeclaredField("currentActivity");
+        field.setAccessible(true);
+        return (Activity) field.get(module);
+    }
+
+    // ======== Activity reference / leak prevention tests (issue #556) ========
+
+    /**
+     * onActivityDestroyed must null out currentActivity when the destroyed activity
+     * is the one currently tracked. This is the core leak fix.
+     */
+    @Test
+    public void onActivityDestroyed_clearsCurrentActivity_whenIdentityMatches() throws Exception {
+        ModuleFeedback mf = mCountly.moduleFeedback;
+
+        Activity act = mock(Activity.class);
+        mf.onActivityStarted(act, 1);
+        Assert.assertSame(act, getCurrentActivity(mf));
+
+        mf.onActivityDestroyed(act);
+        Assert.assertNull(getCurrentActivity(mf));
+    }
+
+    /**
+     * Destroying an activity other than the currently tracked one must NOT clear the field.
+     */
+    @Test
+    public void onActivityDestroyed_doesNotClear_whenDifferentActivity() throws Exception {
+        ModuleFeedback mf = mCountly.moduleFeedback;
+
+        Activity tracked = mock(Activity.class);
+        Activity unrelated = mock(Activity.class);
+        mf.onActivityStarted(tracked, 1);
+
+        mf.onActivityDestroyed(unrelated);
+        Assert.assertSame(tracked, getCurrentActivity(mf));
+    }
+
+    /**
+     * Rotation race regression: when onActivityStarted for the new activity fires before
+     * onActivityDestroyed for the old one, destroying the old activity must not wipe out
+     * the new tracked activity.
+     */
+    @Test
+    public void onActivityDestroyed_doesNotClearNewerActivity_afterRotationRace() throws Exception {
+        ModuleFeedback mf = mCountly.moduleFeedback;
+
+        Activity oldAct = mock(Activity.class);
+        Activity newAct = mock(Activity.class);
+
+        mf.onActivityStarted(oldAct, 1);
+        mf.onActivityStarted(newAct, 2);
+        Assert.assertSame(newAct, getCurrentActivity(mf));
+
+        mf.onActivityDestroyed(oldAct);
+        Assert.assertSame(newAct, getCurrentActivity(mf));
+    }
+
+    /**
+     * onActivityDestroyed must not throw when no activity has been tracked yet.
+     */
+    @Test
+    public void onActivityDestroyed_isSafe_whenNoActivityTracked() throws Exception {
+        ModuleFeedback mf = mCountly.moduleFeedback;
+
+        Activity stray = mock(Activity.class);
+        mf.onActivityDestroyed(stray);
+        Assert.assertNull(getCurrentActivity(mf));
+    }
+
+    /**
+     * The seeded activity path (onInitialActivitySeeded) must also be cleared on destroy.
+     */
+    @Test
+    public void onActivityDestroyed_clearsSeededActivity() throws Exception {
+        ModuleFeedback mf = mCountly.moduleFeedback;
+
+        Activity seeded = mock(Activity.class);
+        mf.onInitialActivitySeeded(seeded);
+        Assert.assertSame(seeded, getCurrentActivity(mf));
+
+        mf.onActivityDestroyed(seeded);
+        Assert.assertNull(getCurrentActivity(mf));
+    }
 }