进一步修改；

DialogX/src/main/java/com/kongzue/dialogx/util/views/DialogXBaseRelativeLayout.java

@@ -102,16 +102,23 @@ public class DialogXBaseRelativeLayout extends RelativeLayout {
             setClipToPadding(false);
         }
         //新增的 设置监听 OnApplyWindowInsetsListener
-        ViewCompat.setOnApplyWindowInsetsListener(
-                this,
-                new androidx.core.view.OnApplyWindowInsetsListener() {
-                    @Override
-                    public WindowInsetsCompat onApplyWindowInsets(View v, WindowInsetsCompat insets) {
-                        paddingView(insets);
-                        return insets;
-                    }
+        FitSystemBarUtils.attachView(this, new FitSystemBarUtils.CallBack() {
+            @Override
+            public boolean isEnable(FitSystemBarUtils.Orientation orientation) {
+                return true;
+            }
+
+            @Override
+            public void unsafeRect(int start, int top, int end, int bottom) {
+                if (unsafePlace == null) {
+                    unsafePlace = new Rect();
                 }
-        );
+                unsafePlace.left = start;
+                unsafePlace.top = top;
+                unsafePlace.right = end;
+                unsafePlace.bottom = bottom;
+            }
+        });
     }
 
 //    @Override
@@ -217,36 +224,36 @@ public class DialogXBaseRelativeLayout extends RelativeLayout {
     protected void onAttachedToWindow() {
         super.onAttachedToWindow();
         if (!isInEditMode()) {
-            final ViewParent parent = getParent();
-            if (parent instanceof View) {
-                ViewCompat.setFitsSystemWindows(this, ViewCompat.getFitsSystemWindows((View) parent));
-            }
-            ViewCompat.requestApplyInsets(this);
+//            final ViewParent parent = getParent();
+//            if (parent instanceof View) {
+//                ViewCompat.setFitsSystemWindows(this, ViewCompat.getFitsSystemWindows((View) parent));
+//            }
+//            ViewCompat.requestApplyInsets(this);
 
             if (getParentDialog() == null || getParentDialog().getOwnActivity() == null) return;
 
-            View decorView = (View) getParent();
-            if (decorView != null) {
-                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
-                    parentKey = Integer.toHexString(decorView.hashCode());
-                    getDynamicWindowInsetsAnimationListener(parentKey).add(dynamicWindowInsetsAnimationListener = new DynamicWindowInsetsAnimationListener() {
-                        @Override
-                        public void onChange(WindowInsets windowInsets) {
-                            paddingView(windowInsets);
-                        }
-                    });
-                    paddingWindowInsetsByDefault();
-                    initDynamicSafeAreaListener();
-                } else {
-                    decorView.getViewTreeObserver().addOnGlobalLayoutListener(decorViewLayoutListener = new ViewTreeObserver.OnGlobalLayoutListener() {
-                        @Override
-                        public void onGlobalLayout() {
-                            paddingWindowInsetsByDefault();
-                        }
-                    });
-                    decorViewLayoutListener.onGlobalLayout();
-                }
-            }
+//            View decorView = (View) getParent();
+//            if (decorView != null) {
+//                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+//                    parentKey = Integer.toHexString(decorView.hashCode());
+//                    getDynamicWindowInsetsAnimationListener(parentKey).add(dynamicWindowInsetsAnimationListener = new DynamicWindowInsetsAnimationListener() {
+//                        @Override
+//                        public void onChange(WindowInsets windowInsets) {
+//                            paddingView(windowInsets);
+//                        }
+//                    });
+//                    paddingWindowInsetsByDefault();
+//                    initDynamicSafeAreaListener();
+//                } else {
+//                    decorView.getViewTreeObserver().addOnGlobalLayoutListener(decorViewLayoutListener = new ViewTreeObserver.OnGlobalLayoutListener() {
+//                        @Override
+//                        public void onGlobalLayout() {
+//                            paddingWindowInsetsByDefault();
+//                        }
+//                    });
+//                    decorViewLayoutListener.onGlobalLayout();
+//                }
+//            }
 
             if (onLifecycleCallBack != null) {
                 onLifecycleCallBack.onShow();
@@ -273,8 +280,11 @@ public class DialogXBaseRelativeLayout extends RelativeLayout {
 
     boolean useWindowInsetsAnimation = false;
 
+
+    private void initDynamicSafeAreaListener() {}
+
     @RequiresApi(api = Build.VERSION_CODES.KITKAT_WATCH)
-    private void initDynamicSafeAreaListener() {
+    private void initDynamicSafeAreaListenerOld() {
         View decorView = (View) getParent();
         if (decorView != null) {
             try {
@@ -304,13 +314,15 @@ public class DialogXBaseRelativeLayout extends RelativeLayout {
 
     private void paddingWindowInsetsByDefault() {
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
-            paddingView(getRootWindowInsets());
+//            paddingView(getRootWindowInsets());
         } else {
-            getWindowInsetsByDisplayMetrics();
+//            getWindowInsetsByDisplayMetrics();
         }
     }
 
-    private void getWindowInsetsByDisplayMetrics() {
+    private void getWindowInsetsByDisplayMetrics() {}
+
+    private void getWindowInsetsByDisplayMetricsOld() {
         if (getParentDialog() == null || getParentDialog().getOwnActivity() == null) return;
         DisplayMetrics displayMetrics = new DisplayMetrics();
         getParentDialog().getOwnActivity().getWindowManager().getDefaultDisplay().getRealMetrics(displayMetrics);
@@ -388,10 +400,10 @@ public class DialogXBaseRelativeLayout extends RelativeLayout {
     public void requestFocusOnResume() {
         log("#requestFocusOnResume");
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q && getRootWindowInsets() != null && getRootWindowInsets().getStableInsets() != null) {
-            paddingView(getRootWindowInsets().getStableInsets());
+//            paddingView(getRootWindowInsets().getStableInsets());
         }
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT_WATCH) {
-            initDynamicSafeAreaListener();
+//            initDynamicSafeAreaListener();
         }
         View findFocusView = findFocus();
         if (findFocusView != null && findFocusView != this) {
@@ -410,7 +422,9 @@ public class DialogXBaseRelativeLayout extends RelativeLayout {
 
     protected Rect unsafePlace = new Rect();
 
-    private void paddingView(int left, int top, int right, int bottom) {
+    private void paddingView(int left, int top, int right, int bottom) {}
+
+    private void paddingViewOld(int left, int top, int right, int bottom) {
         unsafePlace = new Rect(left, top, right, bottom);
         if (onSafeInsetsChangeListener != null) onSafeInsetsChangeListener.onChange(unsafePlace);
         MaxRelativeLayout bkgView = findViewById(R.id.bkg);
@@ -458,7 +472,7 @@ public class DialogXBaseRelativeLayout extends RelativeLayout {
     public DialogXBaseRelativeLayout setAutoUnsafePlacePadding(boolean autoUnsafePlacePadding) {
         this.autoUnsafePlacePadding = autoUnsafePlacePadding;
         if (!autoUnsafePlacePadding) {
-            setPadding(extraPadding[0], extraPadding[1], extraPadding[2], extraPadding[3]);
+//            setPadding(extraPadding[0], extraPadding[1], extraPadding[2], extraPadding[3]);
         }
         return this;
     }
@@ -563,7 +577,8 @@ public class DialogXBaseRelativeLayout extends RelativeLayout {
     }
 
     public int getUseAreaHeight() {
-        return getHeight() - getRootPaddingBottom();
+//        return getHeight() - getRootPaddingBottom();
+        return getHeight() - getPaddingBottom() - getPaddingTop();
     }
 
     protected void log(String s) {

DialogX/src/main/java/com/kongzue/dialogx/util/views/FitSystemBarUtils.java

@@ -0,0 +1,292 @@
+package com.kongzue.dialogx.util.views;
+
+
+import static androidx.core.view.WindowInsetsAnimationCompat.Callback.DISPATCH_MODE_CONTINUE_ON_SUBTREE;
+
+import android.graphics.Rect;
+import android.os.Build;
+import android.view.View;
+
+import androidx.annotation.NonNull;
+import androidx.core.graphics.Insets;
+import androidx.core.view.DisplayCutoutCompat;
+import androidx.core.view.ViewCompat;
+import androidx.core.view.WindowInsetsAnimationCompat;
+import androidx.core.view.WindowInsetsCompat;
+
+import java.util.List;
+
+public class FitSystemBarUtils {
+
+    //当前是否正在平滑填充中
+    private boolean inSmoothingPadding = false;
+
+    public boolean isInSmoothingPadding() {
+        return inSmoothingPadding;
+    }
+
+    //是否需要处理挖孔屏，刘海屏
+    public boolean safeCutOutPadding = true;
+
+    //是否需要平滑填充，仅在android R及以上生效，默认开启
+    public boolean smoothPadding = true;
+
+    private View contentView;
+
+    private CallBack callBack;
+
+    /**
+     * 绑定到View
+     *
+     * @param view 指定View
+     */
+    public static FitSystemBarUtils attachView(View view) {
+        return attachView(view, new CallBack() {
+            @Override
+            public boolean isEnable(Orientation orientation) {
+                return true;
+            }
+
+            @Override
+            public void unsafeRect(int start, int top, int end, int bottom) {
+
+            }
+        });
+    }
+
+    /**
+     * 绑定到View
+     *
+     * @param view     指定View
+     * @param callBack 用于判断是否需要某条边的padding，会非常频繁的调用，所以不要在里面做需要耗时的操作，以免卡UI线程
+     */
+    public static FitSystemBarUtils attachView(View view, CallBack callBack) {
+        return new FitSystemBarUtils(view, callBack);
+    }
+
+
+    /**
+     * 绑定到View
+     *
+     * @param view   指定View
+     * @param start  是否需要paddingStart
+     * @param top    是否需要paddingTop
+     * @param end    是否需要paddingEnd
+     * @param bottom 是否需要paddingBottom
+     */
+    public static FitSystemBarUtils attachView(
+            View view,
+            boolean start,
+            boolean top,
+            boolean end,
+            boolean bottom
+    ) {
+        return attachView(view, new CallBack() {
+            @Override
+            public boolean isEnable(Orientation orientation) {
+                switch (orientation) {
+                    case Start:
+                        return start;
+                    case Top:
+                        return top;
+                    case End:
+                        return end;
+                    case Bottom:
+                        return bottom;
+                }
+                return false;
+            }
+
+            @Override
+            public void unsafeRect(int start, int top, int end, int bottom) {
+
+            }
+        });
+    }
+
+    private FitSystemBarUtils() {
+    }
+
+    public FitSystemBarUtils(View view, CallBack callBack) {
+//        view.setFitsSystemWindows(true);
+        contentView = view;
+        this.callBack = callBack;
+        applyWindowInsets();
+    }
+
+    public void applyWindowInsets() {
+//        view.fitsSystemWindows = true
+        //创建原始padding的快照
+        RelativePadding initialPadding = new RelativePadding(
+                ViewCompat.getPaddingStart(contentView),
+                contentView.getPaddingTop(),
+                ViewCompat.getPaddingEnd(contentView),
+                contentView.getPaddingBottom()
+        );
+        //不带平滑变化的
+        ViewCompat.setOnApplyWindowInsetsListener(contentView, (view, insets) -> {
+            if (inSmoothingPadding) return insets;
+            formatInsets(insets, new RelativePadding(initialPadding));
+            return insets;
+        });
+        //带平滑变化的，但是支支持android R及以上
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+            ViewCompat.setWindowInsetsAnimationCallback(contentView,
+                    new WindowInsetsAnimationCompat.Callback(DISPATCH_MODE_CONTINUE_ON_SUBTREE) {
+
+                        @NonNull
+                        @Override
+                        public WindowInsetsCompat onProgress(
+                                @NonNull WindowInsetsCompat insets,
+                                @NonNull List<WindowInsetsAnimationCompat> runningAnimations
+                        ) {
+                            if (smoothPadding) {
+                                formatInsets(insets, new RelativePadding(initialPadding));
+                            }
+                            return insets;
+                        }
+
+                        @Override
+                        public void onEnd(@NonNull WindowInsetsAnimationCompat animation) {
+                            inSmoothingPadding = false;
+                            super.onEnd(animation);
+                        }
+
+                        @Override
+                        public void onPrepare(@NonNull WindowInsetsAnimationCompat animation) {
+                            inSmoothingPadding = smoothPadding;
+                            super.onPrepare(animation);
+                        }
+                    });
+        }
+
+        if (ViewCompat.isAttachedToWindow(contentView)) {
+            ViewCompat.requestApplyInsets(contentView);
+        } else {
+            contentView.addOnAttachStateChangeListener(new View.OnAttachStateChangeListener() {
+                @Override
+                public void onViewAttachedToWindow(View view) {
+                    view.removeOnAttachStateChangeListener(this);
+                    ViewCompat.requestApplyInsets(view);
+                }
+
+                @Override
+                public void onViewDetachedFromWindow(View view) {
+
+                }
+
+            });
+        }
+    }
+
+    /**
+     * 针对不同版本处理Insets
+     */
+    private void formatInsets(WindowInsetsCompat insetsCompat, RelativePadding initialPadding) {
+        int cutoutPaddingLeft = 0;
+        int cutoutPaddingTop = 0;
+        int cutoutPaddingRight = 0;
+        int cutoutPaddingBottom = 0;
+
+        int systemWindowInsetLeft;
+        int systemWindowInsetTop;
+        int systemWindowInsetRight;
+        int systemWindowInsetBottom;
+
+        if (Build.VERSION.SDK_INT > Build.VERSION_CODES.P) {
+            if (safeCutOutPadding) {
+                DisplayCutoutCompat displayCutout = insetsCompat.getDisplayCutout();
+                if (null != displayCutout) {
+                    cutoutPaddingTop = displayCutout.getSafeInsetTop();
+                    cutoutPaddingLeft = displayCutout.getSafeInsetLeft();
+                    cutoutPaddingRight = displayCutout.getSafeInsetRight();
+                    cutoutPaddingBottom = displayCutout.getSafeInsetRight();
+                }
+            }
+        }
+        if (Build.VERSION.SDK_INT > Build.VERSION_CODES.R) {
+            Insets systemBars = insetsCompat.getInsets(WindowInsetsCompat.Type.systemBars());
+            Insets ime = insetsCompat.getInsets(WindowInsetsCompat.Type.ime());
+            Insets maxInsets = androidx.core.graphics.Insets.max(ime, systemBars);
+            systemWindowInsetLeft = systemBars.left;
+            systemWindowInsetRight = systemBars.right;
+            systemWindowInsetTop = systemBars.top;
+            systemWindowInsetBottom = maxInsets.bottom;
+        } else {
+            systemWindowInsetLeft = insetsCompat.getSystemWindowInsetLeft();
+            systemWindowInsetRight = insetsCompat.getSystemWindowInsetRight();
+            systemWindowInsetTop = insetsCompat.getSystemWindowInsetTop();
+            systemWindowInsetBottom = insetsCompat.getSystemWindowInsetBottom();
+        }
+
+        if (callBack.isEnable(Orientation.Top)) {
+            initialPadding.top += Math.max(systemWindowInsetTop, cutoutPaddingTop);
+        }
+        if (callBack.isEnable(Orientation.Bottom)) {
+            initialPadding.bottom += Math.max(systemWindowInsetBottom, cutoutPaddingBottom);
+        }
+
+        boolean isRtl =
+                ViewCompat.getLayoutDirection(contentView) == ViewCompat.LAYOUT_DIRECTION_RTL;
+        if (callBack.isEnable(Orientation.Start)) {
+            if (isRtl) {
+                initialPadding.start += Math.max(systemWindowInsetRight, cutoutPaddingRight);
+            } else {
+                initialPadding.start += Math.max(systemWindowInsetLeft, cutoutPaddingLeft);
+            }
+        }
+        if (callBack.isEnable(Orientation.End)) {
+            if (isRtl) {
+                initialPadding.end += Math.max(systemWindowInsetLeft, cutoutPaddingLeft);
+            } else {
+                initialPadding.end += Math.max(systemWindowInsetRight, cutoutPaddingRight);
+            }
+        }
+        //四边 非安全区 传递回去
+        callBack.unsafeRect(
+                initialPadding.start,
+                initialPadding.top,
+                initialPadding.end,
+                initialPadding.bottom
+        );
+        initialPadding.applyToView(contentView);
+    }
+
+    public interface CallBack {
+        public boolean isEnable(Orientation orientation);
+
+        public void unsafeRect(int start, int top, int end, int bottom);
+    }
+
+    public static class RelativePadding {
+        int start;
+        int top;
+        int end;
+        int bottom;
+
+        public RelativePadding(int start, int top, int end, int bottom) {
+            this.start = start;
+            this.top = top;
+            this.end = end;
+            this.bottom = bottom;
+        }
+
+        public RelativePadding(RelativePadding other) {
+            start = other.start;
+            top = other.top;
+            end = other.end;
+            bottom = other.bottom;
+        }
+
+        /**
+         * Applies this relative padding to the view.
+         */
+        public void applyToView(View view) {
+            ViewCompat.setPaddingRelative(view, start, top, end, bottom);
+        }
+    }
+
+    enum Orientation {
+        Start, Top, End, Bottom
+    }
+}

app/src/main/java/com/kongzue/dialogxdemo/activity/MainActivity.java

@@ -797,6 +797,9 @@ public class MainActivity extends BaseActivity {
                             }
                         })
                         .setAllowInterceptTouch(false);
+                v.postDelayed(() -> {
+                    startActivity(new Intent(MainActivity.this, MainActivity.class));
+                }, 500);
             }
         });