@Override
public void resized(Rect frame, Rect overscanInsets, Rect contentInsets, Rect visibleInsets,
        Rect stableInsets, Rect outsets, boolean reportDraw,
        MergedConfiguration mergedConfiguration, Rect backDropFrame, boolean forceLayout,
        boolean alwaysConsumeNavBar, int displayId,
        DisplayCutout.ParcelableWrapper displayCutout) {
    if (mergedConfiguration != null && mOuter != null
            && mOuter.mOrientationOnCreation
                    != mergedConfiguration.getMergedConfiguration().orientation) {

        // The orientation of the screen is changing. We better remove the snapshot ASAP as
        // we are going to wait on the new window in any case to unfreeze the screen, and
        // the starting window is not needed anymore.
        sHandler.post(mOuter::remove);
    }
    if (reportDraw) {
        sHandler.obtainMessage(MSG_REPORT_DRAW, mOuter).sendToTarget();
    }
}
 

@Override
public int relayout(IWindow window, int seq, WindowManager.LayoutParams attrs,
        int requestedWidth, int requestedHeight, int viewFlags, int flags, long frameNumber,
        Rect outFrame, Rect outOverscanInsets, Rect outContentInsets, Rect outVisibleInsets,
        Rect outStableInsets, Rect outsets, Rect outBackdropFrame,
        DisplayCutout.ParcelableWrapper cutout, MergedConfiguration mergedConfiguration,
        Surface outSurface) {
    if (false) Slog.d(TAG_WM, ">>>>>> ENTERED relayout from "
            + Binder.getCallingPid());
    Trace.traceBegin(TRACE_TAG_WINDOW_MANAGER, mRelayoutTag);
    int res = mService.relayoutWindow(this, window, seq, attrs,
            requestedWidth, requestedHeight, viewFlags, flags, frameNumber,
            outFrame, outOverscanInsets, outContentInsets, outVisibleInsets,
            outStableInsets, outsets, outBackdropFrame, cutout,
            mergedConfiguration, outSurface);
    Trace.traceEnd(TRACE_TAG_WINDOW_MANAGER);
    if (false) Slog.d(TAG_WM, "<<<<<< EXITING relayout to "
            + Binder.getCallingPid());
    return res;
}
 

private void adjustDisplaySizeRanges(DisplayInfo displayInfo, int displayId, int rotation,
        int uiMode, int dw, int dh) {
    final DisplayCutout displayCutout = calculateDisplayCutoutForRotation(
            rotation).getDisplayCutout();
    final int width = mService.mPolicy.getConfigDisplayWidth(dw, dh, rotation, uiMode,
            displayId, displayCutout);
    if (width < displayInfo.smallestNominalAppWidth) {
        displayInfo.smallestNominalAppWidth = width;
    }
    if (width > displayInfo.largestNominalAppWidth) {
        displayInfo.largestNominalAppWidth = width;
    }
    final int height = mService.mPolicy.getConfigDisplayHeight(dw, dh, rotation, uiMode,
            displayId, displayCutout);
    if (height < displayInfo.smallestNominalAppHeight) {
        displayInfo.smallestNominalAppHeight = height;
    }
    if (height > displayInfo.largestNominalAppHeight) {
        displayInfo.largestNominalAppHeight = height;
    }
}
 

/**
 * Find the safe area of DisplayCutout.
 *
 * @param activity {@link Activity} (Portrait and `windowLayoutInDisplayCutoutMode` != never)
 * @return Safe cutout insets.
 */
public static Rect findCutoutSafeArea(@NonNull Activity activity) {
    final Rect safeInsetRect = new Rect();
    // TODO:Rewrite with android-x
    // TODO:Consider alternatives
    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.P) {
        return safeInsetRect;
    }

    // Fix: getDisplayCutout() on a null object reference (issue #110)
    final WindowInsets windowInsets = activity.getWindow().getDecorView().getRootWindowInsets();
    if (windowInsets == null) {
        return safeInsetRect;
    }

    // set safeInsetRect
    final DisplayCutout displayCutout = windowInsets.getDisplayCutout();
    if (displayCutout != null) {
        safeInsetRect.set(displayCutout.getSafeInsetLeft(), displayCutout.getSafeInsetTop(), displayCutout.getSafeInsetRight(), displayCutout.getSafeInsetBottom());
    }

    return safeInsetRect;
}
 

/**
 * 是否为允许全屏界面显示内容到刘海区域的刘海屏机型（与AndroidManifest中配置对应）
 */
public static boolean allowDisplayToCutout(Activity activity) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
        // 9.0系统全屏界面默认会保留黑边，不允许显示内容到刘海区域
        Window window = activity.getWindow();
        WindowInsets windowInsets = window.getDecorView().getRootWindowInsets();
        if (windowInsets == null) {
            return false;
        }
        DisplayCutout displayCutout = windowInsets.getDisplayCutout();
        if (displayCutout == null) {
            return false;
        }
        List<Rect> boundingRects = displayCutout.getBoundingRects();
        return boundingRects.size() > 0;
    } else {
        return hasCutoutHuawei(activity)
                || hasCutoutOPPO(activity)
                || hasCutoutVIVO(activity)
                || hasCutoutXIAOMI(activity);
    }
}
 

/**
 * Find the safe area of DisplayCutout.
 *
 * @param activity {@link Activity} (Portrait and `windowLayoutInDisplayCutoutMode` != never)
 * @return Safe cutout insets.
 */
public static Rect findCutoutSafeArea(@NonNull Activity activity) {
    final Rect safeInsetRect = new Rect();
    // TODO:Rewrite with android-x
    // TODO:Consider alternatives
    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.P) {
        return safeInsetRect;
    }

    // Fix: getDisplayCutout() on a null object reference (issue #110)
    final WindowInsets windowInsets = activity.getWindow().getDecorView().getRootWindowInsets();
    if (windowInsets == null) {
        return safeInsetRect;
    }

    // set safeInsetRect
    final DisplayCutout displayCutout = windowInsets.getDisplayCutout();
    if (displayCutout != null) {
        safeInsetRect.set(displayCutout.getSafeInsetLeft(), displayCutout.getSafeInsetTop(), displayCutout.getSafeInsetRight(), displayCutout.getSafeInsetBottom());
    }

    return safeInsetRect;
}
 

int getSmallestWidthDpForBounds(Rect bounds) {
    final DisplayInfo di = mDisplayContent.getDisplayInfo();

    final int baseDisplayWidth = mDisplayContent.mBaseDisplayWidth;
    final int baseDisplayHeight = mDisplayContent.mBaseDisplayHeight;
    int minWidth = Integer.MAX_VALUE;

    // Go through all screen orientations and find the orientation in which the task has the
    // smallest width.
    for (int rotation = 0; rotation < 4; rotation++) {
        mTmpRect.set(bounds);
        mDisplayContent.rotateBounds(di.rotation, rotation, mTmpRect);
        final boolean rotated = (rotation == ROTATION_90 || rotation == ROTATION_270);
        mTmpRect2.set(0, 0,
                rotated ? baseDisplayHeight : baseDisplayWidth,
                rotated ? baseDisplayWidth : baseDisplayHeight);
        final int orientation = mTmpRect2.width() <= mTmpRect2.height()
                ? ORIENTATION_PORTRAIT
                : ORIENTATION_LANDSCAPE;
        final int dockSide = getDockSide(mTmpRect, mTmpRect2, orientation);
        final int position = DockedDividerUtils.calculatePositionForBounds(mTmpRect, dockSide,
                getContentWidth());

        final DisplayCutout displayCutout = mDisplayContent.calculateDisplayCutoutForRotation(
                rotation).getDisplayCutout();

        // Since we only care about feasible states, snap to the closest snap target, like it
        // would happen when actually rotating the screen.
        final int snappedPosition = mSnapAlgorithmForRotation[rotation]
                .calculateNonDismissingSnapTarget(position).position;
        DockedDividerUtils.calculateBoundsForPosition(snappedPosition, dockSide, mTmpRect,
                mTmpRect2.width(), mTmpRect2.height(), getContentWidth());
        mService.mPolicy.getStableInsetsLw(rotation, mTmpRect2.width(), mTmpRect2.height(),
                displayCutout, mTmpRect3);
        mService.intersectDisplayInsetBounds(mTmpRect2, mTmpRect3, mTmpRect);
        minWidth = Math.min(mTmpRect.width(), minWidth);
    }
    return (int) (minWidth / mDisplayContent.getDisplayMetrics().density);
}
 

@Override
public int add(IWindow window, int seq, WindowManager.LayoutParams attrs,
        int viewVisibility, Rect outContentInsets, Rect outStableInsets,
        InputChannel outInputChannel) {
    return addToDisplay(window, seq, attrs, viewVisibility, Display.DEFAULT_DISPLAY,
            new Rect() /* outFrame */, outContentInsets, outStableInsets, null /* outOutsets */,
            new DisplayCutout.ParcelableWrapper()  /* cutout */, outInputChannel);
}
 

@Override
public int addToDisplay(IWindow window, int seq, WindowManager.LayoutParams attrs,
        int viewVisibility, int displayId, Rect outFrame, Rect outContentInsets,
        Rect outStableInsets, Rect outOutsets,
        DisplayCutout.ParcelableWrapper outDisplayCutout, InputChannel outInputChannel) {
        // 调用 WMS.addWindow()
    return mService.addWindow(this, window, seq, attrs, viewVisibility, displayId, outFrame,
            outContentInsets, outStableInsets, outOutsets, outDisplayCutout, outInputChannel);
}
 

@Override
public int addToDisplayWithoutInputChannel(IWindow window, int seq, WindowManager.LayoutParams attrs,
        int viewVisibility, int displayId, Rect outContentInsets, Rect outStableInsets) {
    return mService.addWindow(this, window, seq, attrs, viewVisibility, displayId,
            new Rect() /* outFrame */, outContentInsets, outStableInsets, null /* outOutsets */,
            new DisplayCutout.ParcelableWrapper() /* cutout */, null /* outInputChannel */);
}
 

public static WmDisplayCutout computeSafeInsets(DisplayCutout inner,
        int displayWidth, int displayHeight) {
    if (inner == DisplayCutout.NO_CUTOUT || inner.isBoundsEmpty()) {
        return NO_CUTOUT;
    }

    final Size displaySize = new Size(displayWidth, displayHeight);
    final Rect safeInsets = computeSafeInsets(displaySize, inner);
    return new WmDisplayCutout(inner.replaceSafeInsets(safeInsets), displaySize);
}
 

/**
 * Insets the reference frame of the cutout in the given directions.
 *
 * @return a copy of this instance which has been inset
 * @hide
 */
public WmDisplayCutout inset(int insetLeft, int insetTop, int insetRight, int insetBottom) {
    DisplayCutout newInner = mInner.inset(insetLeft, insetTop, insetRight, insetBottom);

    if (mInner == newInner) {
        return this;
    }

    Size frame = mFrameSize == null ? null : new Size(
            mFrameSize.getWidth() - insetLeft - insetRight,
            mFrameSize.getHeight() - insetTop - insetBottom);

    return new WmDisplayCutout(newInner, frame);
}
 

private WmDisplayCutout calculateDisplayCutoutForRotationUncached(
        DisplayCutout cutout, int rotation) {
    if (cutout == null || cutout == DisplayCutout.NO_CUTOUT) {
        return WmDisplayCutout.NO_CUTOUT;
    }
    if (rotation == ROTATION_0) {
        return WmDisplayCutout.computeSafeInsets(
                cutout, mInitialDisplayWidth, mInitialDisplayHeight);
    }
    final boolean rotated = (rotation == ROTATION_90 || rotation == ROTATION_270);
    final List<Rect> bounds = WmDisplayCutout.computeSafeInsets(
                    cutout, mInitialDisplayWidth, mInitialDisplayHeight)
            .getDisplayCutout().getBoundingRects();
    transformPhysicalToLogicalCoordinates(rotation, mInitialDisplayWidth, mInitialDisplayHeight,
            mTmpMatrix);
    final Region region = Region.obtain();
    for (int i = 0; i < bounds.size(); i++) {
        final Rect rect = bounds.get(i);
        final RectF rectF = new RectF(bounds.get(i));
        mTmpMatrix.mapRect(rectF);
        rectF.round(rect);
        region.op(rect, Op.UNION);
    }

    return WmDisplayCutout.computeSafeInsets(DisplayCutout.fromBounds(region),
            rotated ? mInitialDisplayHeight : mInitialDisplayWidth,
            rotated ? mInitialDisplayWidth : mInitialDisplayHeight);
}
 

/**
 * If display metrics changed, overrides are not set and it's not just a rotation - update base
 * values.
 */
private void updateBaseDisplayMetricsIfNeeded() {
    // Get real display metrics without overrides from WM.
    mService.mDisplayManagerInternal.getNonOverrideDisplayInfo(mDisplayId, mDisplayInfo);
    final int orientation = mDisplayInfo.rotation;
    final boolean rotated = (orientation == ROTATION_90 || orientation == ROTATION_270);
    final int newWidth = rotated ? mDisplayInfo.logicalHeight : mDisplayInfo.logicalWidth;
    final int newHeight = rotated ? mDisplayInfo.logicalWidth : mDisplayInfo.logicalHeight;
    final int newDensity = mDisplayInfo.logicalDensityDpi;
    final DisplayCutout newCutout = mDisplayInfo.displayCutout;

    final boolean sizeChanged = mInitialDisplayWidth != newWidth
            || mInitialDisplayHeight != newHeight;
    final boolean displayMetricsChanged = sizeChanged
            || mInitialDisplayDensity != mDisplayInfo.logicalDensityDpi
            || !Objects.equals(mInitialDisplayCutout, newCutout);

    if (displayMetricsChanged) {
        // Check if display size or density is forced.
        final boolean isDisplaySizeForced = mBaseDisplayWidth != mInitialDisplayWidth
                || mBaseDisplayHeight != mInitialDisplayHeight;
        final boolean isDisplayDensityForced = mBaseDisplayDensity != mInitialDisplayDensity;

        // If there is an override set for base values - use it, otherwise use new values.
        updateBaseDisplayMetrics(isDisplaySizeForced ? mBaseDisplayWidth : newWidth,
                isDisplaySizeForced ? mBaseDisplayHeight : newHeight,
                isDisplayDensityForced ? mBaseDisplayDensity : newDensity);

        // Real display metrics changed, so we should also update initial values.
        mInitialDisplayWidth = newWidth;
        mInitialDisplayHeight = newHeight;
        mInitialDisplayDensity = newDensity;
        mInitialDisplayCutout = newCutout;
        mService.reconfigureDisplayLocked(this);
    }

    if (isDefaultDisplay && sizeChanged) {
        mService.mH.post(mService.mAmInternal::notifyDefaultDisplaySizeChanged);
    }
}
 

@Override
public void resized(Rect frame, Rect overscanInsets, Rect contentInsets,
        Rect visibleInsets, Rect stableInsets, Rect outsets, boolean reportDraw,
        MergedConfiguration mergedConfiguration, Rect backDropRect, boolean forceLayout,
        boolean alwaysConsumeNavBar, int displayId,
        DisplayCutout.ParcelableWrapper displayCutout) {
    Message msg = mCaller.obtainMessageIO(MSG_WINDOW_RESIZED,
            reportDraw ? 1 : 0, outsets);
    mCaller.sendMessage(msg);
}
 

/**
 * 获得刘海区域信息
 */
@TargetApi(28)
public void getNotchParams() {
    final View decorView = getWindow().getDecorView();
    if (decorView != null) {
        decorView.post(new Runnable() {
            @Override
            public void run() {
                WindowInsets windowInsets = decorView.getRootWindowInsets();
                if (windowInsets != null) {
                    // 当全屏顶部显示黑边时，getDisplayCutout()返回为null
                    DisplayCutout displayCutout = windowInsets.getDisplayCutout();
                    Log.e("TAG", "安全区域距离屏幕左边的距离 SafeInsetLeft:" + displayCutout.getSafeInsetLeft());
                    Log.e("TAG", "安全区域距离屏幕右部的距离 SafeInsetRight:" + displayCutout.getSafeInsetRight());
                    Log.e("TAG", "安全区域距离屏幕顶部的距离 SafeInsetTop:" + displayCutout.getSafeInsetTop());
                    Log.e("TAG", "安全区域距离屏幕底部的距离 SafeInsetBottom:" + displayCutout.getSafeInsetBottom());
                    // 获得刘海区域
                    List<Rect> rects = displayCutout.getBoundingRects();
                    if (rects == null || rects.size() == 0) {
                        Log.e("TAG", "不是刘海屏");
                    } else {
                        Log.e("TAG", "刘海屏数量:" + rects.size());
                        for (Rect rect : rects) {
                            Log.e("TAG", "刘海屏区域：" + rect);
                        }
                    }
                }
            }
        });
    }
}
 

@RequiresApi(Build.VERSION_CODES.P)
private DisplayCutout getDisplayCutout() {
    Activity activity = getActivity();
    if (activity != null) {
        WindowInsets windowInsets = activity.getWindow().getDecorView().getRootWindowInsets();
        if (windowInsets != null) {
            return windowInsets.getDisplayCutout();
        }
    }

    return null;
}
 

@TargetApi(28)
private static boolean attachHasOfficialNotch(View view) {
    WindowInsets windowInsets = view.getRootWindowInsets();
    if (windowInsets != null) {
        DisplayCutout displayCutout = windowInsets.getDisplayCutout();
        return displayCutout != null;
    } else {
        throw new IllegalStateException("activity has not yet attach to window, you must call `isCutout` after `Activity#onAttachedToWindow` is called.");
    }
}
 

/**
 * 是否有刘海屏
 */
public static boolean hasNotchInScreen(Activity activity) {
    // android  P 以上有标准 API 来判断是否有刘海屏
    if (Build.VERSION.SDK_INT >= 28) {
        try {
            DisplayCutout displayCutout = activity.getWindow().getDecorView().getRootWindowInsets().getDisplayCutout();
            if (displayCutout != null) {
                // 说明有刘海屏
                return true;
            }
        } catch (Exception e) {
            return false;
        }
    } else {
        // 通过其他方式判断是否有刘海屏  目前官方提供有开发文档的就 小米，vivo，华为（荣耀），oppo
        String manufacturer = Build.MANUFACTURER;
        if (manufacturer == null || manufacturer.length() == 0) {
            return false;
        } else if (manufacturer.equalsIgnoreCase("HUAWEI")) {
            return hasNotchHw(activity);
        } else if (manufacturer.equalsIgnoreCase("xiaomi")) {
            return hasNotchXiaoMi(activity);
        } else if (manufacturer.equalsIgnoreCase("oppo")) {
            return hasNotchOPPO(activity);
        } else if (manufacturer.equalsIgnoreCase("vivo")) {
            return hasNotchVIVO(activity);
        } else {
            return false;
        }
    }
    return false;
}
 

/**
 * 是否有刘海屏
 */
public static boolean hasNotchInScreen(Activity activity) {
    // android  P 以上有标准 API 来判断是否有刘海屏
    if (Build.VERSION.SDK_INT >= 28) {
        try {
            DisplayCutout displayCutout = activity.getWindow().getDecorView().getRootWindowInsets().getDisplayCutout();
            if (displayCutout != null) {
                // 说明有刘海屏
                return true;
            }
        } catch (Exception e) {
            return false;
        }
    } else {
        // 通过其他方式判断是否有刘海屏  目前官方提供有开发文档的就 小米，vivo，华为（荣耀），oppo
        String manufacturer = Build.MANUFACTURER;
        if (manufacturer == null || manufacturer.length() == 0) {
            return false;
        } else if (manufacturer.equalsIgnoreCase("HUAWEI")) {
            return hasNotchHw(activity);
        } else if (manufacturer.equalsIgnoreCase("xiaomi")) {
            return hasNotchXiaoMi(activity);
        } else if (manufacturer.equalsIgnoreCase("oppo")) {
            return hasNotchOPPO(activity);
        } else if (manufacturer.equalsIgnoreCase("vivo")) {
            return hasNotchVIVO(activity);
        } else {
            return false;
        }
    }
    return false;
}
 

/**
 * 判断全面屏
 *
 * @param activity Activity
 * @return boolean
 */
public static boolean isFullScreenDisplay(@NonNull Activity activity) {
    if (isSupportP()) {
        // 谷歌官方提供
        Window window = activity.getWindow();
        if (window != null) {
            WindowInsets windowInsets = window.getDecorView().getRootWindowInsets();
            if (windowInsets != null) {
                DisplayCutout displayCutout = windowInsets.getDisplayCutout();
                if (displayCutout != null) {
                    List<Rect> rects = displayCutout.getBoundingRects();
                    // 一般为刘海屏即为全面屏
                    if (rects != null && rects.size() > 0) {
                        return true;
                    }
                }
            }
        }
    }

    WindowManager wm = (WindowManager) activity.getSystemService(Context.WINDOW_SERVICE);
    if (wm != null) {
        Display defaultDisplay = wm.getDefaultDisplay();
        if (defaultDisplay != null) {
            DisplayMetrics dm = new DisplayMetrics();
            defaultDisplay.getRealMetrics(dm);
            float heightPixels = dm.heightPixels;
            float widthPixels = dm.widthPixels;
            // 通过分比率比例去判断
            return heightPixels / widthPixels >= 1.96f;
        }
    }
    return false;
}
 

/**
 * @param view
 * @return false indicates the failure to get the result
 */
@TargetApi(28)
private static boolean attachHasOfficialNotch(View view) {
    WindowInsets windowInsets = view.getRootWindowInsets();
    if (windowInsets != null) {
        DisplayCutout displayCutout = windowInsets.getDisplayCutout();
        sHasNotch = displayCutout != null;
        return true;
    } else {
        // view not attached, do nothing
        return false;
    }
}
 

@TargetApi(28)
private static void getOfficialSafeInsetRect(View view, Rect out) {
    if (view == null) {
        return;
    }
    WindowInsets rootWindowInsets = view.getRootWindowInsets();
    if (rootWindowInsets == null) {
        return;
    }
    DisplayCutout displayCutout = rootWindowInsets.getDisplayCutout();
    if (displayCutout != null) {
        out.set(displayCutout.getSafeInsetLeft(), displayCutout.getSafeInsetTop(),
                displayCutout.getSafeInsetRight(), displayCutout.getSafeInsetBottom());
    }
}
 

/**
 *
 * @param view
 * @return false indicates the failure to get the result
 */
@TargetApi(28)
private static boolean attachHasOfficialNotch(View view){
    WindowInsets windowInsets = view.getRootWindowInsets();
    if(windowInsets != null){
        DisplayCutout displayCutout = windowInsets.getDisplayCutout();
        sHasNotch = displayCutout != null;
        return true;
    }else{
        // view not attached, do nothing
        return false;
    }
}
 

@TargetApi(28)
private static void getOfficialSafeInsetRect(View view, Rect out) {
    if(view == null){
        return;
    }
    WindowInsets rootWindowInsets = view.getRootWindowInsets();
    if(rootWindowInsets == null){
        return;
    }
    DisplayCutout displayCutout = rootWindowInsets.getDisplayCutout();
    if(displayCutout != null){
        out.set(displayCutout.getSafeInsetLeft(), displayCutout.getSafeInsetTop(),
                displayCutout.getSafeInsetRight(), displayCutout.getSafeInsetBottom());
    }
}
 

/**
 * 获得DisplayCutout
 * Gets display cutout.
 *
 * @param activity the activity
 * @return the display cutout
 */
private static DisplayCutout getDisplayCutout(Activity activity) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
        if (activity != null) {
            Window window = activity.getWindow();
            if (window != null) {
                WindowInsets windowInsets = window.getDecorView().getRootWindowInsets();
                if (windowInsets != null) {
                    return windowInsets.getDisplayCutout();
                }
            }
        }
    }
    return null;
}
 

private static DisplayCutout getDisplayCutout(View view) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
        if (view != null) {
            WindowInsets windowInsets = view.getRootWindowInsets();
            if (windowInsets != null) {
                return windowInsets.getDisplayCutout();
            }
        }
    }
    return null;
}
 

/**
 * 获得刘海屏高度
 * Notch height int.
 *
 * @param activity the activity
 * @return the int
 */
public static int getNotchHeight(Activity activity) {
    int notchHeight = 0;
    int statusBarHeight = ImmersionBar.getStatusBarHeight(activity);
    DisplayCutout displayCutout = getDisplayCutout(activity);
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P && displayCutout != null) {
        if (activity.getResources().getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT) {
            notchHeight = displayCutout.getSafeInsetTop();
        } else {
            if (displayCutout.getSafeInsetLeft() == 0) {
                notchHeight = displayCutout.getSafeInsetRight();
            } else {
                notchHeight = displayCutout.getSafeInsetLeft();
            }
        }
    } else {
        if (hasNotchAtXiaoMi(activity)) {
            notchHeight = getXiaoMiNotchHeight(activity);
        }
        if (hasNotchAtHuaWei(activity)) {
            notchHeight = getHuaWeiNotchSize(activity)[1];
        }
        if (hasNotchAtVIVO(activity)) {
            notchHeight = dp2px(activity, 32);
            if (notchHeight < statusBarHeight) {
                notchHeight = statusBarHeight;
            }
        }
        if (hasNotchAtOPPO(activity)) {
            notchHeight = 80;
            if (notchHeight < statusBarHeight) {
                notchHeight = statusBarHeight;
            }
        }
    }
    return notchHeight;
}
 

/**
 * 获得DisplayCutout
 * Gets display cutout.
 *
 * @param activity the activity
 * @return the display cutout
 */
private static DisplayCutout getDisplayCutout(Activity activity) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
        if (activity != null) {
            Window window = activity.getWindow();
            if (window != null) {
                WindowInsets windowInsets = window.getDecorView().getRootWindowInsets();
                if (windowInsets != null) {
                    return windowInsets.getDisplayCutout();
                }
            }
        }
    }
    return null;
}
 

private static DisplayCutout getDisplayCutout(View view) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
        if (view != null) {
            WindowInsets windowInsets = view.getRootWindowInsets();
            if (windowInsets != null) {
                return windowInsets.getDisplayCutout();
            }
        }
    }
    return null;
}