fix: [3914] Fix safe area insets on android 34 (#3915)

* fix: [3914] Fix safe area insets on android 34

This fixes both safe area insets and form bottom padding editing on android 34.
By trial and error, I found that, with respect to immersive mode, android 34 behaves like
android 33 and earlier unless we explicitly enable it by calling WindowCompat.setDecorFitsSystemWindows(window, false),
which we don't do.  And it is not possible to detect whether this has been called.
This patch adjusts immersive heuristics to check for API 35+ instead of 34+ when determining if we are drawing
edge to edge on the screen.

This impacts the safe area insets implementation as well as form bottom padding editing.

As part of this, I have re-enabled the android.useSafeAreaInsets display property by default
so taht we use safe area insets by default.  This can be opted out.

The reason is that on API 35+ it needs this setting to work properly.

* fix extra bottom padding when ime is visible

Author: shannah

Ports/Android/src/com/codename1/impl/android/AndroidImplementation.java

@@ -1292,11 +1292,56 @@ public int getDeviceDensity() {
         return Display.DENSITY_MEDIUM;
     }
 
+    public static boolean isImmersive() {
+        if (getActivity() == null) {
+            return false;
+        }
+        return isImmersive(getActivity().getWindow());
+    }
+    public static boolean isImmersive(Window window) {
+        if (Build.VERSION.SDK_INT >= 35) {
+            // Android 15+ is always immersive (overlay mode by default)
+            return true;
+        }
+        // On Android 34 and below, we can't detect decorFitsSystemWindows
+        // reliably at runtime. So the app must make the decision explicitly.
+        return false;
+    }
+    public static Rect getSystemBarInsets(final View rootView) {
+        final Rect result = new Rect(0, 0, 0, 0);
+        try {
+            Object insets = View.class
+                    .getMethod("getRootWindowInsets")
+                    .invoke(rootView);
+            if (insets == null) return result;
+            // Get android.view.WindowInsets$Type.systemBars()
+            Class typeClass = Class.forName("android.view.WindowInsets$Type");
+            int systemBarsMask = ((Integer) typeClass
+                    .getMethod("systemBars")
+                    .invoke(null)).intValue();
+            // Call insets.getInsets(int)
+            Object insetsObject = insets.getClass()
+                    .getMethod("getInsets", new Class[]{int.class})
+                    .invoke(insets, new Object[]{systemBarsMask});
+            if (insetsObject == null) return result;
+            Class insetsClass = insetsObject.getClass();
+            int left = ((Integer) insetsClass.getField("left").get(insetsObject)).intValue();
+            int top = ((Integer) insetsClass.getField("top").get(insetsObject)).intValue();
+            int right = ((Integer) insetsClass.getField("right").get(insetsObject)).intValue();
+            int bottom = ((Integer) insetsClass.getField("bottom").get(insetsObject)).intValue();
+            result.set(left, top, right, bottom);
+        } catch (Throwable t) {
+            t.printStackTrace();  // Optional: log this or suppress if expected
+        }
+        return result;
+    }
+
+
     public Rectangle getDisplaySafeArea(Rectangle rect) {
         if (rect == null) {
             rect = new Rectangle();
         }
-        if (getProperty("android.useSafeAreaInsets", "false").equals("false")) {
+        if (getProperty("android.useSafeAreaInsets", "true").equals("false")) {
             return super.getDisplaySafeArea(rect);
         }
         if (this.myView != null) {

Ports/Android/src/com/codename1/impl/android/CodenameOneView.java

@@ -164,6 +164,7 @@ public void visibilityChangedTo(boolean visible) {
 
     private void updateSafeArea() {
         final Activity activity = CodenameOneView.this.implementation.getActivity();
+
         final Rect rect = this.safeArea;
         final View rootView = activity.getWindow().getDecorView();
         if (Build.VERSION.SDK_INT >= VERSION_CODE_P) {
@@ -182,10 +183,59 @@ private void updateSafeArea() {
                         Method getSafeInsetRight = displayCutoutClass.getMethod("getSafeInsetRight");
                         Method getSafeInsetBottom = displayCutoutClass.getMethod("getSafeInsetBottom");
 
-                        rect.left = ((Integer) getSafeInsetLeft.invoke(cutout)).intValue();
-                        rect.top = ((Integer) getSafeInsetTop.invoke(cutout)).intValue();
-                        rect.right = ((Integer) getSafeInsetRight.invoke(cutout)).intValue();
-                        rect.bottom = ((Integer) getSafeInsetBottom.invoke(cutout)).intValue();
+                        int left = ((Integer) getSafeInsetLeft.invoke(cutout)).intValue();
+                        int top = ((Integer) getSafeInsetTop.invoke(cutout)).intValue();
+                        int right = ((Integer) getSafeInsetRight.invoke(cutout)).intValue();
+                        int bottom = ((Integer) getSafeInsetBottom.invoke(cutout)).intValue();
+                        boolean imeVisible = false;
+                        try {
+                            Method isVisibleMethod = insets.getClass().getMethod("isVisible", int.class);
+                            Class<?> typeClass = Class.forName("android.view.WindowInsets$Type");
+                            int imeType = ((Integer) typeClass.getMethod("ime").invoke(null)).intValue();
+                            imeVisible = (Boolean) isVisibleMethod.invoke(insets, imeType);
+                        } catch (Throwable t) {
+                            // Fallback or log
+                        }
+
+                        Rect systemBarInsets = AndroidImplementation.getSystemBarInsets(rootView);
+                        top = Math.max(systemBarInsets.top, top);
+                        if (imeVisible) {
+                            // Avoid double-counting the bottom gesture bar
+                            bottom = Math.max(bottom, 0);
+                        } else {
+                            bottom = Math.max(systemBarInsets.bottom, bottom);
+                        }
+                        left = Math.max(systemBarInsets.left, left);
+                        right = Math.max(systemBarInsets.right, right);
+
+                        if (!AndroidImplementation.isImmersive()) {
+                            top -= systemBarInsets.top;
+                            if (!imeVisible) {
+                                bottom -= systemBarInsets.bottom;
+                            }
+                            left -= systemBarInsets.left;
+                            right -= systemBarInsets.right;
+                        }
+
+                        // Only apply if at least one is non-zero
+                        if (left != 0 || top != 0 || right != 0 || bottom != 0) {
+                            boolean isChanged = rect.left != left
+                                    || rect.right != right
+                                    || rect.top != top
+                                    || rect.bottom != bottom;
+                            rect.left = left;
+                            rect.top = top;
+                            rect.right = right;
+                            rect.bottom = bottom;
+
+                            if (isChanged) {
+                                Display.getInstance().callSerially(new Runnable() {
+                                    public void run() {
+                                        AndroidImplementation.getInstance().revalidate();
+                                    }
+                                });
+                            }
+                        }
                     }
                 }
             } catch (Exception e) {

Ports/Android/src/com/codename1/impl/android/InPlaceEditView.java

@@ -1398,51 +1398,7 @@ private static void setEditMode(final boolean resize) {
     }
 
     private static boolean isImmersive(Window window) {
-        View decor = window.getDecorView();
-
-        // ---------- Modern branch : API 30+ ----------
-        if (Build.VERSION.SDK_INT >= 30) {
-            try {
-                // WindowInsets insets = decor.getRootWindowInsets();
-                Object insets = View.class
-                        .getMethod("getRootWindowInsets")
-                        .invoke(decor);
-                if (insets == null) return false;
-
-                // int mask = WindowInsets.Type.systemBars();
-                Class<?> typeCls =
-                        Class.forName("android.view.WindowInsets$Type");
-                int systemBars = (Integer) typeCls
-                        .getMethod("systemBars")
-                        .invoke(null);
-
-                // boolean barsVisible = insets.isVisible(mask);
-                boolean barsVisible = (Boolean) insets.getClass()
-                        .getMethod("isVisible", int.class)
-                        .invoke(insets, systemBars);
-
-                /* --------------------------------------------------
-                 * Edge-to-edge is guaranteed on API 35+ anyway, and
-                 * `getDecorFitsSystemWindows()` no longer exists on
-                 * API 36.  We treat everything >=30 as edge-to-edge
-                 * (decorFits = false) and only look at bar visibility
-                 * to decide if we’re *immersive*.
-                 * -------------------------------------------------- */
-                return !barsVisible;    // immersive ⇢ bars are hidden
-            } catch (Throwable ignore) {
-                System.out.println("Error: " + ignore);
-            }
-        }
-
-        // ---------- Legacy branch : API 19-29 ----------
-        int f = decor.getSystemUiVisibility();
-        boolean immersiveBits =
-                (f & View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY) != 0 ||
-                        (f & View.SYSTEM_UI_FLAG_IMMERSIVE)        != 0;
-        boolean barsHidden =
-                (f & View.SYSTEM_UI_FLAG_HIDE_NAVIGATION) != 0 &&
-                        (f & View.SYSTEM_UI_FLAG_FULLSCREEN)      != 0;
-        return immersiveBits && barsHidden;
+        return AndroidImplementation.isImmersive(window);
     }
 
     private static void applyImeInsetPaddingReflection(View rootView) {