New config enum to deal with in-app layouts and how they should appear in the app. Changing default bahaviour to follow the app layout

Author: franco-zalamena-iterable

CHANGELOG.md

@@ -3,8 +3,36 @@ All notable changes to this project will be documented in this file.
 This project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
-### Fixed
-- In-app messages now match the host app's system bar behavior instead of overriding it. This fixes fullscreen in-apps drawing content behind the status bar.
+### Added
+- New `IterableInAppDisplayMode` enum to control how in-app messages interact with system bars. Configure via `IterableConfig.Builder.setInAppDisplayMode()`:
+  - `FOLLOW_APP_LAYOUT` (default) — matches the host app's system bar configuration. No change needed for existing integrations.
+  - `FORCE_EDGE_TO_EDGE` — forces in-app content to draw behind system bars with transparent status and navigation bars.
+  - `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.
+
+### Changed
+- In-app messages now match the host app's system bar behavior by default. Previously, fullscreen in-apps would always draw content behind the status bar, which could cause UI elements like the close button to be obscured. The new default (`FOLLOW_APP_LAYOUT`) detects whether your app uses edge-to-edge and matches that configuration.
+
+### Migration guide
+**No action required for most apps.** The new default `FOLLOW_APP_LAYOUT` automatically adapts to your app's layout.
+
+If you relied on the previous behavior where fullscreen in-apps drew content behind the status bar, you can restore it explicitly:
+
+```java
+// Restore previous behavior: in-app content draws behind system bars
+IterableConfig config = new IterableConfig.Builder()
+    .setInAppDisplayMode(IterableInAppDisplayMode.FORCE_EDGE_TO_EDGE)
+    .build();
+```
+
+If you want to ensure the close button is always accessible regardless of app configuration:
+
+```java
+// In-app content never goes behind system bars
+IterableConfig config = new IterableConfig.Builder()
+    .setInAppDisplayMode(IterableInAppDisplayMode.FORCE_RESPECT_BOUNDS)
+    .build();
+```
 
 ## [3.7.0]
 - Replaced the deprecated `AsyncTask`-based push notification handling with `WorkManager` for improved reliability and compatibility with modern Android versions. No action is required.

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#FOLLOW_APP_LAYOUT}.
+     */
+    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.FOLLOW_APP_LAYOUT;
 
         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#FOLLOW_APP_LAYOUT}, 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,36 @@
+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 {
+
+    /**
+     * Default. 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,
+
+    /**
+     * 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.
+     */
+    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

@@ -34,6 +34,7 @@
 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 {
@@ -77,6 +78,7 @@ public class IterableInAppFragmentHTMLNotification extends DialogFragment implem
     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));
@@ -148,6 +150,7 @@ public void onCreate(@Nullable Bundle savedInstanceState) {
         }
 
         notification = this;
+        displayMode = resolveDisplayMode();
     }
 
     @NonNull
@@ -176,7 +179,7 @@ public void onCancel(DialogInterface dialog) {
         }
 
         hostIsEdgeToEdge = isHostActivityEdgeToEdge();
-        configureSystemBarBehavior(dialog.getWindow());
+        configureSystemBarsForMode(dialog.getWindow());
         return dialog;
     }
 
@@ -288,7 +291,7 @@ public void run() {
     @Override
     public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
         super.onViewCreated(view, savedInstanceState);
-        if (getInAppLayout(insetPadding) != InAppLayout.FULLSCREEN && hostIsEdgeToEdge) {
+        if (shouldApplySystemBarInsets()) {
             ViewCompat.setOnApplyWindowInsetsListener(view, (v, insets) -> {
                 Insets sysBars = insets.getInsets(WindowInsetsCompat.Type.systemBars());
                 v.setPadding(0, sysBars.top, 0, sysBars.bottom);
@@ -500,11 +503,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() {
@@ -684,21 +683,94 @@ static int roundToNearest90Degrees(int orientation) {
         }
     }
 
-    private void configureSystemBarBehavior(Window window) {
+    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.FOLLOW_APP_LAYOUT;
+    }
+
+    @SuppressWarnings("deprecation")
+    private void configureSystemBarsForMode(Window window) {
         if (window == null) return;
+        InAppLayout layout = getInAppLayout(insetPadding);
+
+        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, layout);
+                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, InAppLayout layout) {
         Activity activity = getActivity();
         if (activity == null || activity.getWindow() == null) return;
 
         if (hostIsEdgeToEdge) {
-            WindowCompat.setDecorFitsSystemWindows(window, false);
-            window.setStatusBarColor(Color.TRANSPARENT);
-            window.setNavigationBarColor(Color.TRANSPARENT);
+            applyEdgeToEdge(window);
         } else {
-            window.setStatusBarColor(activity.getWindow().getStatusBarColor());
-            window.setNavigationBarColor(activity.getWindow().getNavigationBarColor());
+            if (Build.VERSION.SDK_INT < 35) {
+                window.setStatusBarColor(activity.getWindow().getStatusBarColor());
+                window.setNavigationBarColor(activity.getWindow().getNavigationBarColor());
+            }
         }
     }
 
+    private boolean shouldApplySystemBarInsets() {
+        InAppLayout layout = getInAppLayout(insetPadding);
+
+        return switch (displayMode) {
+            case FORCE_EDGE_TO_EDGE, FORCE_FULLSCREEN -> false;
+            case FORCE_RESPECT_BOUNDS -> true;
+            default ->
+                layout != InAppLayout.FULLSCREEN && hostIsEdgeToEdge;
+        };
+    }
+
     private boolean isHostActivityEdgeToEdge() {
         Activity activity = getActivity();
         if (activity == null || activity.getWindow() == null) return false;
@@ -714,6 +786,7 @@ private boolean isHostActivityEdgeToEdge() {
         return false;
     }
 
+    @SuppressWarnings("deprecation")
     private boolean hasEdgeToEdgeLegacyFlags(Activity activity) {
         int flags = activity.getWindow().getDecorView().getSystemUiVisibility();
         return (flags & View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN) != 0;