[SDK-337] Fix for status bar overlap on in-app messages (#988)

Author: franco-zalamena-iterable

CHANGELOG.md

@@ -3,14 +3,38 @@ All notable changes to this project will be documented in this file.
 This project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
+### Added
+- New `IterableInAppDisplayMode` enum to control how in-app messages interact with system bars. Configure via `IterableConfig.Builder.setInAppDisplayMode()`:
+  - `FORCE_EDGE_TO_EDGE` (default) — draws in-app content behind system bars with transparent status and navigation bars. This preserves the previous SDK behavior.
+  - `FOLLOW_APP_LAYOUT` — matches the host app's system bar configuration automatically.
+  - `FORCE_FULLSCREEN` — hides the status bar entirely for all in-app messages.
+  - `FORCE_RESPECT_BOUNDS` — ensures in-app content never overlaps system bars, keeping UI elements like the close button always accessible.
+- Added `imageScaleType` to `IterableEmbeddedViewConfig` to allow configuring how the image is scaled within the 16:9 container for embedded message views.
+- Added default values to all `IterableEmbeddedViewConfig` constructor parameters for easier configuration.
+
 ### Fixed
 - Fixed `IterableEmbeddedView` card layout rendering issues: image now displays at a 16:9 aspect ratio instead of collapsing to zero height, card container no longer expands to fill the parent, missing end margin on the card is now applied, bottom spacing on buttons is no longer cut off, and the image properly clips to the card's rounded corners.
 - Fixed `ConcurrentModificationException` crash during device token registration caused by concurrent access to `deviceAttributes`.
 - Fixed possible `NoSuchMethodException` crash on Android 5-10 caused by using `Map.of()` which is unavailable on those versions
 
-### Added
-- Added `imageScaleType` to `IterableEmbeddedViewConfig` to allow configuring how the image is scaled within the 16:9 container for embedded message views.
-- Added default values to all `IterableEmbeddedViewConfig` constructor parameters for easier configuration.
+### Migration guide
+**No action required for most apps.** The default `FORCE_EDGE_TO_EDGE` preserves the existing behavior where in-app content draws behind system bars.
+
+If the close button in your fullscreen in-app messages is obscured by the status bar, you can fix it by choosing one of these modes:
+
+```java
+// Automatically match the host app's system bar configuration
+IterableConfig config = new IterableConfig.Builder()
+    .setInAppDisplayMode(IterableInAppDisplayMode.FOLLOW_APP_LAYOUT)
+    .build();
+```
+
+```java
+// Ensure in-app content never goes behind system bars
+IterableConfig config = new IterableConfig.Builder()
+    .setInAppDisplayMode(IterableInAppDisplayMode.FORCE_RESPECT_BOUNDS)
+    .build();
+```
 
 ### Removed
 - Removed insecure `AES/CBC/PKCS5Padding` encryption from `IterableDataEncryptor`. The SDK now exclusively uses `AES/GCM/NoPadding`. The legacy CBC algorithm was only used on Android versions below KitKat (API 19), which have been unsupported since `minSdkVersion` was raised to 21.

iterableapi/src/main/java/com/iterable/iterableapi/IterableConfig.java

@@ -140,6 +140,12 @@ public class IterableConfig {
     @Nullable
     final IterableAPIMobileFrameworkInfo mobileFrameworkInfo;
 
+    /**
+     * Controls how in-app messages interact with the system bars (status bar, navigation bar).
+     * Defaults to {@link IterableInAppDisplayMode#FORCE_EDGE_TO_EDGE}.
+     */
+    final IterableInAppDisplayMode inAppDisplayMode;
+
     /**
      * Base URL for Webview content loading. Specifically used to enable CORS for external resources.
      * If null or empty, defaults to empty string (original behavior with about:blank origin).
@@ -183,6 +189,7 @@ private IterableConfig(Builder builder) {
         decryptionFailureHandler = builder.decryptionFailureHandler;
         mobileFrameworkInfo = builder.mobileFrameworkInfo;
         webViewBaseUrl = builder.webViewBaseUrl;
+        inAppDisplayMode = builder.inAppDisplayMode;
     }
 
     public static class Builder {
@@ -211,6 +218,7 @@ public static class Builder {
         private IterableIdentityResolution identityResolution = new IterableIdentityResolution();
         private IterableUnknownUserHandler iterableUnknownUserHandler;
         private String webViewBaseUrl;
+        private IterableInAppDisplayMode inAppDisplayMode = IterableInAppDisplayMode.FORCE_EDGE_TO_EDGE;
 
         public Builder() {}
 
@@ -453,6 +461,17 @@ public Builder setMobileFrameworkInfo(@NonNull IterableAPIMobileFrameworkInfo mo
             return this;
         }
 
+        /**
+         * Set how in-app messages interact with the system bars (status bar, navigation bar).
+         * Defaults to {@link IterableInAppDisplayMode#FORCE_EDGE_TO_EDGE}, which preserves existing behavior.
+         * @param inAppDisplayMode the display mode for in-app messages
+         */
+        @NonNull
+        public Builder setInAppDisplayMode(@NonNull IterableInAppDisplayMode inAppDisplayMode) {
+            this.inAppDisplayMode = inAppDisplayMode;
+            return this;
+        }
+
         /**
          * Set the base URL for WebView content loading. Used to enable CORS for external resources.
          * If not set or null, defaults to empty string (original behavior with about:blank origin).

iterableapi/src/main/java/com/iterable/iterableapi/IterableInAppDisplayMode.java

@@ -0,0 +1,37 @@
+package com.iterable.iterableapi;
+
+/**
+ * Controls how in-app messages interact with the system bars (status bar, navigation bar).
+ * <p>
+ * This setting is configured via {@link IterableConfig.Builder#setInAppDisplayMode(IterableInAppDisplayMode)}
+ * and applies globally to all in-app messages displayed by the SDK.
+ */
+public enum IterableInAppDisplayMode {
+
+    /**
+     * The in-app message follows the host app's current layout configuration.
+     * If the app is edge-to-edge, the in-app will display edge-to-edge.
+     * If the app respects system bar bounds, the in-app will too.
+     */
+    FOLLOW_APP_LAYOUT,
+
+    /**
+     * Default. Forces in-app messages to display edge-to-edge, drawing content behind system bars.
+     * The in-app content will extend behind the status bar and navigation bar.
+     * This preserves the behavior of previous SDK versions.
+     */
+    FORCE_EDGE_TO_EDGE,
+
+    /**
+     * Forces in-app messages to display in fullscreen mode, hiding the status bar entirely.
+     * Uses legacy FLAG_FULLSCREEN on API &lt; 30 and WindowInsetsController on API 30+.
+     */
+    FORCE_FULLSCREEN,
+
+    /**
+     * Forces in-app messages to respect system bar boundaries.
+     * Content will never draw behind the status bar or navigation bar,
+     * ensuring UI elements like the close button are always accessible.
+     */
+    FORCE_RESPECT_BOUNDS
+}

iterableapi/src/main/java/com/iterable/iterableapi/IterableInAppFragmentHTMLNotification.java

@@ -6,7 +6,6 @@
 import android.content.DialogInterface;
 import android.content.res.Resources;
 import android.graphics.Color;
-import android.graphics.Point;
 import android.graphics.Rect;
 import android.graphics.drawable.ColorDrawable;
 import android.graphics.drawable.Drawable;
@@ -17,8 +16,6 @@
 import android.os.Bundle;
 import android.os.Handler;
 import android.os.Looper;
-import android.util.DisplayMetrics;
-import android.view.Display;
 import android.view.Gravity;
 import android.view.LayoutInflater;
 import android.view.OrientationEventListener;
@@ -36,7 +33,9 @@
 import androidx.core.graphics.ColorUtils;
 import androidx.core.graphics.Insets;
 import androidx.core.view.ViewCompat;
+import androidx.core.view.WindowCompat;
 import androidx.core.view.WindowInsetsCompat;
+import androidx.core.view.WindowInsetsControllerCompat;
 import androidx.fragment.app.DialogFragment;
 
 public class IterableInAppFragmentHTMLNotification extends DialogFragment implements IterableWebView.HTMLNotificationCallbacks {
@@ -79,6 +78,8 @@ public class IterableInAppFragmentHTMLNotification extends DialogFragment implem
     private boolean shouldAnimate;
     private double inAppBackgroundAlpha;
     private String inAppBackgroundColor;
+    private boolean hostIsEdgeToEdge;
+    private IterableInAppDisplayMode displayMode = IterableInAppDisplayMode.FOLLOW_APP_LAYOUT;
 
     public static IterableInAppFragmentHTMLNotification createInstance(@NonNull String htmlString, boolean callbackOnCancel, @NonNull IterableHelper.IterableUrlCallback clickCallback, @NonNull IterableInAppLocation location, @NonNull String messageId, @NonNull Double backgroundAlpha, @NonNull Rect padding) {
         return IterableInAppFragmentHTMLNotification.createInstance(htmlString, callbackOnCancel, clickCallback, location, messageId, backgroundAlpha, padding, false, new IterableInAppMessage.InAppBgColor(null, 0.0f));
@@ -150,6 +151,7 @@ public void onCreate(@Nullable Bundle savedInstanceState) {
         }
 
         notification = this;
+        displayMode = resolveDisplayMode();
     }
 
     @NonNull
@@ -177,13 +179,8 @@ public void onCancel(DialogInterface dialog) {
             applyWindowGravity(dialog.getWindow(), "onCreateDialog");
         }
 
-        if (getInAppLayout(insetPadding) == InAppLayout.FULLSCREEN) {
-            dialog.getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
-        } else if (getInAppLayout(insetPadding) != InAppLayout.TOP) {
-            // For TOP layout in-app, status bar will be opaque so that the in-app content does not overlap with translucent status bar.
-            // For other non-fullscreen in-apps layouts (BOTTOM and CENTER), status bar will be translucent
-            dialog.getWindow().setFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS, WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS);
-        }
+        hostIsEdgeToEdge = isHostActivityEdgeToEdge();
+        configureSystemBarsForMode(dialog.getWindow());
         return dialog;
     }
 
@@ -192,10 +189,6 @@ public void onCancel(DialogInterface dialog) {
     public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
         getDialog().getWindow().setBackgroundDrawable(new ColorDrawable(Color.TRANSPARENT));
 
-        if (getInAppLayout(insetPadding) == InAppLayout.FULLSCREEN) {
-            getDialog().getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
-        }
-
         // Set initial window gravity based on inset padding (only for non-fullscreen)
         if (getInAppLayout(insetPadding) != InAppLayout.FULLSCREEN) {
             applyWindowGravity(getDialog().getWindow(), "onCreateView");
@@ -299,9 +292,7 @@ public void run() {
     @Override
     public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
         super.onViewCreated(view, savedInstanceState);
-        // Handle edge-to-edge insets with modern approach (only for non-fullscreen)
-        // Full screen in-apps should not have padding from system bars
-        if (getInAppLayout(insetPadding) != InAppLayout.FULLSCREEN) {
+        if (shouldApplySystemBarInsets()) {
             ViewCompat.setOnApplyWindowInsetsListener(view, (v, insets) -> {
                 Insets sysBars = insets.getInsets(WindowInsetsCompat.Type.systemBars());
                 v.setPadding(0, sysBars.top, 0, sysBars.bottom);
@@ -513,11 +504,7 @@ public void run() {
             }
         };
 
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
-            webView.postOnAnimationDelayed(dismissWebViewRunnable, 400);
-        } else {
-            webView.postDelayed(dismissWebViewRunnable, 400);
-        }
+        webView.postOnAnimationDelayed(dismissWebViewRunnable, 400);
     }
 
     private void processMessageRemoval() {
@@ -606,30 +593,11 @@ public void run() {
                         return;
                     }
 
-                    DisplayMetrics displayMetrics = activity.getResources().getDisplayMetrics();
                     Window window = notification.getDialog().getWindow();
                     Rect insetPadding = notification.insetPadding;
 
-                    WindowManager wm = (WindowManager) getContext().getSystemService(Context.WINDOW_SERVICE);
-                    Display display = wm.getDefaultDisplay();
-                    Point size = new Point();
-
-                    // Get the correct screen size based on api level
-                    // https://stackoverflow.com/questions/35780980/getting-the-actual-screen-height-android
-                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
-                        display.getRealSize(size);
-                    } else {
-                        display.getSize(size);
-                    }
-
-                    int webViewWidth = size.x;
-                    int webViewHeight = size.y;
-
-                    //Check if the dialog is full screen
                     if (insetPadding.bottom == 0 && insetPadding.top == 0) {
-                        //Handle full screen
-                        window.setLayout(webViewWidth, webViewHeight);
-                        getDialog().getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
+                        window.setLayout(WindowManager.LayoutParams.MATCH_PARENT, WindowManager.LayoutParams.MATCH_PARENT);
                     } else {
                         // Resize the WebView directly with explicit size
                         float relativeHeight = height * getResources().getDisplayMetrics().density;
@@ -716,6 +684,132 @@ static int roundToNearest90Degrees(int orientation) {
         }
     }
 
+    private IterableInAppDisplayMode resolveDisplayMode() {
+        try {
+            IterableConfig config = IterableApi.sharedInstance.config;
+            if (config != null) {
+                return config.inAppDisplayMode;
+            }
+        } catch (Exception e) {
+            IterableLogger.w(TAG, "Could not resolve display mode from config, using default");
+        }
+        return IterableInAppDisplayMode.FORCE_EDGE_TO_EDGE;
+    }
+
+    @SuppressWarnings("deprecation")
+    private void configureSystemBarsForMode(Window window) {
+        if (window == null) return;
+
+        switch (displayMode) {
+            case FORCE_EDGE_TO_EDGE:
+                applyEdgeToEdge(window);
+                break;
+
+            case FORCE_FULLSCREEN:
+                hideStatusBar(window);
+                break;
+
+            case FORCE_RESPECT_BOUNDS:
+                applyRespectBounds(window);
+                break;
+
+            case FOLLOW_APP_LAYOUT:
+            default:
+                configureSystemBarsFollowingApp(window);
+                break;
+        }
+    }
+
+    private void applyEdgeToEdge(Window window) {
+        WindowCompat.setDecorFitsSystemWindows(window, false);
+        // On API 35+, system bars are transparent by default; these setters are no-ops
+        if (Build.VERSION.SDK_INT < 35) {
+            window.setStatusBarColor(Color.TRANSPARENT);
+            window.setNavigationBarColor(Color.TRANSPARENT);
+        }
+    }
+
+    @SuppressWarnings("deprecation")
+    private void hideStatusBar(Window window) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+            WindowCompat.setDecorFitsSystemWindows(window, false);
+            WindowInsetsControllerCompat controller = WindowCompat.getInsetsController(window, window.getDecorView());
+            controller.hide(WindowInsetsCompat.Type.statusBars());
+            controller.setSystemBarsBehavior(WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE);
+        } else {
+            window.setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
+        }
+    }
+
+    private void applyRespectBounds(Window window) {
+        WindowCompat.setDecorFitsSystemWindows(window, true);
+    }
+
+    @SuppressWarnings("deprecation")
+    private void configureSystemBarsFollowingApp(Window window) {
+        Activity activity = getActivity();
+        if (activity == null || activity.getWindow() == null) return;
+
+        if (hostIsEdgeToEdge) {
+            applyEdgeToEdge(window);
+        } else {
+            if (Build.VERSION.SDK_INT < 35) {
+                window.setStatusBarColor(activity.getWindow().getStatusBarColor());
+                window.setNavigationBarColor(activity.getWindow().getNavigationBarColor());
+            }
+        }
+    }
+
+    private boolean shouldApplySystemBarInsets() {
+        switch (displayMode) {
+            case FORCE_EDGE_TO_EDGE:
+            case FORCE_FULLSCREEN:
+                return false;
+            case FORCE_RESPECT_BOUNDS:
+                return true;
+            case FOLLOW_APP_LAYOUT:
+            default:
+                InAppLayout layout = getInAppLayout(insetPadding);
+                return layout != InAppLayout.FULLSCREEN && hostIsEdgeToEdge;
+        }
+    }
+
+    private boolean isHostActivityEdgeToEdge() {
+        Activity activity = getActivity();
+        if (activity == null || activity.getWindow() == null) return false;
+
+        if (hasEdgeToEdgeLegacyFlags(activity)) {
+            return true;
+        }
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+            return isContentDrawnBehindSystemBars(activity);
+        }
+
+        return false;
+    }
+
+    @SuppressWarnings("deprecation")
+    private boolean hasEdgeToEdgeLegacyFlags(Activity activity) {
+        int flags = activity.getWindow().getDecorView().getSystemUiVisibility();
+        return (flags & View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN) != 0;
+    }
+
+    private boolean isContentDrawnBehindSystemBars(Activity activity) {
+        View contentView = activity.findViewById(android.R.id.content);
+        if (contentView == null) return false;
+
+        int contentTop = getViewTopPositionInWindow(contentView);
+        boolean statusBarPushesContentDown = contentTop > 0;
+        return !statusBarPushesContentDown;
+    }
+
+    private int getViewTopPositionInWindow(View view) {
+        int[] position = new int[2];
+        view.getLocationInWindow(position);
+        return position[1];
+    }
+
     /**
      * Sets the window gravity based on inset padding
      *