• Android 沉浸式状态栏（全透明状态栏）全适配方案。解决透明状态栏后依然有半透明灰色问题。

    可以适配Android 11的沉浸式。状态栏完全透明，没有半透明灰色。

    1. package com.iflytek.jzapp.utils.immersive;
    2.  
    3. import android.app.Activity;
    4. import android.graphics.Color;
    5. import android.os.Build;
    6. import android.view.Gravity;
    7. import android.view.View;
    8. import android.view.ViewGroup;
    9. import android.view.Window;
    10. import android.view.WindowManager;
    11. import android.widget.FrameLayout;
    12.  
    13. import androidx.appcompat.app.AppCompatActivity;
    14. import androidx.core.view.ViewCompat;
    15.  
    16.  
    17. /**
    18.  * @author：luck
    19.  * @data：2018/3/28 下午1:00
    20.  * @描述: 沉浸式相关
    21.  */
    22.  
    23. public class ImmersiveManager {
    24.  
    25.     /**
    26.      * 注意：使用最好将布局xml 跟布局加入    android:fitsSystemWindows="true" ，这样可以避免有些手机上布局顶边的问题
    27.      *
    28.      * @param baseActivity        这个会留出来状态栏和底栏的空白
    29.      * @param statusBarColor      状态栏的颜色
    30.      * @param navigationBarColor  导航栏的颜色
    31.      * @param isDarkStatusBarIcon 状态栏图标颜色是否是深（黑）色  false状态栏图标颜色为白色
    32.      */
    33.     public static void immersiveAboveAPI23(AppCompatActivity baseActivity, int statusBarColor, int navigationBarColor, boolean isDarkStatusBarIcon) {
    34.         immersiveAboveAPI23(baseActivity, false, false, statusBarColor, navigationBarColor, isDarkStatusBarIcon);
    35.     }
    36.  
    37.  
    38.     /**
    39.      * @param baseActivity
    40.      * @param statusBarColor     状态栏的颜色
    41.      * @param navigationBarColor 导航栏的颜色
    42.      */
    43.     public static void immersiveAboveAPI23(AppCompatActivity baseActivity, boolean isMarginStatusBar
    44.             , boolean isMarginNavigationBar, int statusBarColor, int navigationBarColor, boolean isDarkStatusBarIcon) {
    45.         try {
    46.             Window window = baseActivity.getWindow();
    47.             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT && Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
    48.                 //4.4版本及以上 5.0版本及以下
    49.                 if (isDarkStatusBarIcon) {
    50.                     initBarBelowLOLLIPOP(baseActivity);
    51.                 } else {
    52.                     window.setFlags(
    53.                             WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS,
    54.                             WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS);
    55.                 }
    56.             } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
    57.                 if (isMarginStatusBar && isMarginNavigationBar) {
    58.                     //5.0版本及以上
    59.                     window.clearFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS
    60.                             | WindowManager.LayoutParams.FLAG_TRANSLUCENT_NAVIGATION);
    61.                     LightStatusBarUtils.setLightStatusBar(baseActivity, true
    62.                             , true
    63.                             , statusBarColor == Color.TRANSPARENT
    64.                             , isDarkStatusBarIcon);
    65.  
    66.                     window.addFlags(WindowManager.LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS);
    67.                 } else if (!isMarginStatusBar && !isMarginNavigationBar) {
    68.                     if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M && isDarkStatusBarIcon) {
    69.                         initBarBelowLOLLIPOP(baseActivity);
    70.                     } else {
    71.                         window.requestFeature(Window.FEATURE_NO_TITLE);
    72.                         window.clearFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS
    73.                                 | WindowManager.LayoutParams.FLAG_TRANSLUCENT_NAVIGATION);
    74.  
    75.                         LightStatusBarUtils.setLightStatusBar(baseActivity, false
    76.                                 , false
    77.                                 , statusBarColor == Color.TRANSPARENT
    78.                                 , isDarkStatusBarIcon);
    79.  
    80.                         window.addFlags(WindowManager.LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS);
    81.                     }
    82.                 } else if (!isMarginStatusBar) {
    83.                     window.requestFeature(Window.FEATURE_NO_TITLE);
    84.                     window.clearFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS
    85.                             | WindowManager.LayoutParams.FLAG_TRANSLUCENT_NAVIGATION);
    86.                     LightStatusBarUtils.setLightStatusBar(baseActivity, false
    87.                             , true
    88.                             , statusBarColor == Color.TRANSPARENT
    89.                             , isDarkStatusBarIcon);
    90.  
    91.                     window.addFlags(WindowManager.LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS);
    92.                 } else {
    93.                     //留出来状态栏 不留出来导航栏 没找到办法。。
    94.                     return;
    95.                 }
    96.  
    97.                 window.setStatusBarColor(statusBarColor);
    98.                 window.setNavigationBarColor(navigationBarColor);
    99.  
    100.             }
    101.         } catch (Exception e) {
    102.             e.printStackTrace();
    103.         }
    104.     }
    105.  
    106.  
    107.     private final static String TAG_FAKE_STATUS_BAR_VIEW = "TAG_FAKE_STATUS_BAR_VIEW";
    108.     private final static String TAG_MARGIN_ADDED = "TAG_MARGIN_ADDED";
    109.     private final static String TAG_NAVIGATION_BAR_VIEW = "TAG_NAVIGATION_BAR_VIEW";
    110.  
    111.     /**
    112.      * 透明状态栏
    113.      *
    114.      * @param activity
    115.      * @param isDarkStatusBarBlack
    116.      */
    117.     public static void translucentStatusBar(Activity activity, boolean isDarkStatusBarBlack) {
    118.         Window window = activity.getWindow();
    119.         //添加Flag把状态栏设为可绘制模式
    120.         window.addFlags(WindowManager.LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS);
    121.         //如果为全透明模式，取消设置Window半透明的Flag
    122.         window.clearFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS);
    123.         //设置状态栏为透明
    124.         window.setStatusBarColor(Color.TRANSPARENT);
    125.         View decor = window.getDecorView();
    126.         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
    127.             //设置window的状态栏不可见,且状态栏字体是白色
    128.             if (isDarkStatusBarBlack) {
    129.                 decor.setSystemUiVisibility(View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR | View.SYSTEM_UI_FLAG_LAYOUT_STABLE | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN);
    130.             } else {
    131.                 window.getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_STABLE | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN);
    132.             }
    133.         } else {
    134.             //初始化5.0以下，4.4以上沉浸式
    135.             if (isDarkStatusBarBlack) {
    136.                 initBarBelowLOLLIPOP(activity);
    137.             } else {
    138.                 window.getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_STABLE | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN);
    139.             }
    140.         }
    141.         //view不根据系统窗口来调整自己的布局
    142.         ViewGroup mContentView = window.findViewById(Window.ID_ANDROID_CONTENT);
    143.         View mChildView = mContentView.getChildAt(0);
    144.         if (mChildView != null) {
    145.             mChildView.setFitsSystemWindows(false);
    146.             ViewCompat.requestApplyInsets(mChildView);
    147.         }
    148.     }
    149.  
    150.     private static void initBarBelowLOLLIPOP(Activity activity) {
    151.         //透明状态栏
    152.         Window mWindow = activity.getWindow();
    153.         mWindow.addFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS);
    154.         //创建一个假的状态栏
    155.         setupStatusBarView(activity);
    156.         //判断是否存在导航栏，是否禁止设置导航栏
    157.         if (DensityUtil.isNavBarVisible(activity)) {
    158.             //透明导航栏，设置这个，如果有导航栏，底部布局会被导航栏遮住
    159.             mWindow.addFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_NAVIGATION);
    160.             //创建一个假的导航栏
    161.             setupNavBarView(activity);
    162.         }
    163.     }
    164.  
    165.     private static void setupStatusBarView(Activity activity) {
    166.         Window mWindow = activity.getWindow();
    167.         View statusBarView = mWindow.getDecorView().findViewWithTag(TAG_FAKE_STATUS_BAR_VIEW);
    168.         if (statusBarView == null) {
    169.             statusBarView = new View(activity);
    170.             FrameLayout.LayoutParams params = new FrameLayout.LayoutParams(FrameLayout.LayoutParams.MATCH_PARENT,
    171.                     DensityUtil.getStatusBarHeight(activity));
    172.             params.gravity = Gravity.TOP;
    173.             statusBarView.setLayoutParams(params);
    174.             statusBarView.setVisibility(View.VISIBLE);
    175.             statusBarView.setTag(TAG_MARGIN_ADDED);
    176.             ((ViewGroup) mWindow.getDecorView()).addView(statusBarView);
    177.         }
    178.         statusBarView.setBackgroundColor(Color.TRANSPARENT);
    179.     }
    180.  
    181.     private static void setupNavBarView(Activity activity) {
    182.         Window window = activity.getWindow();
    183.         View navigationBarView = window.getDecorView().findViewWithTag(TAG_NAVIGATION_BAR_VIEW);
    184.         if (navigationBarView == null) {
    185.             navigationBarView = new View(activity);
    186.             navigationBarView.setTag(TAG_NAVIGATION_BAR_VIEW);
    187.             ((ViewGroup) window.getDecorView()).addView(navigationBarView);
    188.         }
    189.  
    190.         FrameLayout.LayoutParams params;
    191.         if (DensityUtil.isNavigationAtBottom(activity)) {
    192.             params = new FrameLayout.LayoutParams(FrameLayout.LayoutParams.MATCH_PARENT, DensityUtil.getNavigationBarHeight(activity));
    193.             params.gravity = Gravity.BOTTOM;
    194.         } else {
    195.             params = new FrameLayout.LayoutParams(DensityUtil.getNavigationBarWidth(activity), FrameLayout.LayoutParams.MATCH_PARENT);
    196.             params.gravity = Gravity.END;
    197.         }
    198.         navigationBarView.setLayoutParams(params);
    199.         navigationBarView.setBackgroundColor(Color.TRANSPARENT);
    200.         navigationBarView.setVisibility(View.VISIBLE);
    201.     }
    202. }
    1. package com.iflytek.jzapp.utils.immersive;
    2.  
    3. import android.annotation.TargetApi;
    4. import android.app.Activity;
    5. import android.os.Build;
    6. import android.view.View;
    7. import android.view.Window;
    8. import android.view.WindowManager;
    9.  
    10. import java.lang.reflect.Field;
    11. import java.lang.reflect.Method;
    12.  
    13. /**
    14.  * @author：luck
    15.  * @data：2018/3/28 下午1:01
    16.  * @描述: 沉浸式
    17.  */
    18.  
    19. public class LightStatusBarUtils {
    20.     public static void setLightStatusBarAboveAPI23(Activity activity, boolean isMarginStatusBar
    21.             , boolean isMarginNavigationBar, boolean isTransStatusBar, boolean dark) {
    22.         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
    23.             setLightStatusBar(activity, isMarginStatusBar, isMarginNavigationBar, isTransStatusBar, dark);
    24.         }
    25.     }
    26.  
    27.     public static void setLightStatusBar(Activity activity, boolean dark) {
    28.         setLightStatusBar(activity, false, false, false, dark);
    29.     }
    30.  
    31.     public static void setLightStatusBar(Activity activity, boolean isMarginStatusBar
    32.             , boolean isMarginNavigationBar, boolean isTransStatusBar, boolean dark) {
    33.         switch (RomUtils.getLightStatausBarAvailableRomType()) {
    34.             case RomUtils.AvailableRomType.MIUI:
    35.                 if (RomUtils.getMIUIVersionCode() >= 7) {
    36.                     setAndroidNativeLightStatusBar(activity, isMarginStatusBar, isMarginNavigationBar, isTransStatusBar, dark);
    37.                 } else {
    38.                     setMIUILightStatusBar(activity, isMarginStatusBar, isMarginNavigationBar, isTransStatusBar, dark);
    39.                 }
    40.                 break;
    41.  
    42.             case RomUtils.AvailableRomType.FLYME:
    43.                 setFlymeLightStatusBar(activity, isMarginStatusBar, isMarginNavigationBar, isTransStatusBar, dark);
    44.                 break;
    45.  
    46.             case RomUtils.AvailableRomType.ANDROID_NATIVE:
    47.                 setAndroidNativeLightStatusBar(activity, isMarginStatusBar, isMarginNavigationBar, isTransStatusBar, dark);
    48.                 break;
    49.  
    50.             case RomUtils.AvailableRomType.NA:
    51.                 // N/A do nothing
    52.                 break;
    53.         }
    54.     }
    55.  
    56.  
    57.     private static boolean setMIUILightStatusBar(Activity activity, boolean isMarginStatusBar
    58.             , boolean isMarginNavigationBar, boolean isTransStatusBar, boolean darkmode) {
    59.         initStatusBarStyle(activity, isMarginStatusBar, isMarginNavigationBar);
    60.  
    61.         Class<? extends Window> clazz = activity.getWindow().getClass();
    62.         try {
    63.             int darkModeFlag = 0;
    64.             Class<?> layoutParams = Class.forName("android.view.MiuiWindowManager$LayoutParams");
    65.             Field field = layoutParams.getField("EXTRA_FLAG_STATUS_BAR_DARK_MODE");
    66.             darkModeFlag = field.getInt(layoutParams);
    67.             Method extraFlagField = clazz.getMethod("setExtraFlags", int.class, int.class);
    68.             extraFlagField.invoke(activity.getWindow(), darkmode ? darkModeFlag : 0, darkModeFlag);
    69.             return true;
    70.         } catch (Exception e) {
    71.             setAndroidNativeLightStatusBar(activity, isMarginStatusBar, isMarginNavigationBar, isTransStatusBar, darkmode);
    72.         }
    73.         return false;
    74.     }
    75.  
    76.     private static boolean setFlymeLightStatusBar(Activity activity, boolean isMarginStatusBar
    77.             , boolean isMarginNavigationBar, boolean isTransStatusBar, boolean dark) {
    78.         boolean result = false;
    79.         if (activity != null) {
    80.             initStatusBarStyle(activity, isMarginStatusBar, isMarginNavigationBar);
    81.             try {
    82.                 WindowManager.LayoutParams lp = activity.getWindow().getAttributes();
    83.                 Field darkFlag = WindowManager.LayoutParams.class
    84.                         .getDeclaredField("MEIZU_FLAG_DARK_STATUS_BAR_ICON");
    85.                 Field meizuFlags = WindowManager.LayoutParams.class
    86.                         .getDeclaredField("meizuFlags");
    87.                 darkFlag.setAccessible(true);
    88.                 meizuFlags.setAccessible(true);
    89.                 int bit = darkFlag.getInt(null);
    90.                 int value = meizuFlags.getInt(lp);
    91.                 if (dark) {
    92.                     value |= bit;
    93.                 } else {
    94.                     value &= ~bit;
    95.                 }
    96.                 meizuFlags.setInt(lp, value);
    97.                 activity.getWindow().setAttributes(lp);
    98.                 result = true;
    99.  
    100.                 if (RomUtils.getFlymeVersion() >= 7) {
    101.                     setAndroidNativeLightStatusBar(activity, isMarginStatusBar, isMarginNavigationBar, isTransStatusBar, dark);
    102.                 }
    103.             } catch (Exception e) {
    104.                 setAndroidNativeLightStatusBar(activity, isMarginStatusBar, isMarginNavigationBar, isTransStatusBar, dark);
    105.             }
    106.         }
    107.         return result;
    108.     }
    109.  
    110.     @TargetApi(11)
    111.     private static void setAndroidNativeLightStatusBar(Activity activity, boolean isMarginStatusBar
    112.             , boolean isMarginNavigationBar, boolean isTransStatusBar, boolean isDarkStatusBarIcon) {
    113.  
    114.         try {
    115.             if (isTransStatusBar) {
    116.                 Window window = activity.getWindow();
    117.                 if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
    118.                     if (isMarginStatusBar && isMarginNavigationBar) {
    119.                         //5.0版本及以上
    120.                         if (isDarkStatusBarIcon && Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
    121.                             window.getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_STABLE
    122.                                     | View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR);
    123.                         } else {
    124.                             window.getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_STABLE);
    125.                         }
    126.                     } else if (!isMarginStatusBar && !isMarginNavigationBar) {
    127.  
    128.                         if (isDarkStatusBarIcon && Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
    129.                             window.getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
    130. //                                    | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
    131.                                     | View.SYSTEM_UI_FLAG_LAYOUT_STABLE
    132.                                     | View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR);
    133.                         } else {
    134.                             window.getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
    135. //                                    | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
    136.                                     | View.SYSTEM_UI_FLAG_LAYOUT_STABLE);
    137.                         }
    138.  
    139.  
    140.                     } else if (!isMarginStatusBar && isMarginNavigationBar) {
    141.                         if (isDarkStatusBarIcon && Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
    142.                             window.getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
    143.                                     | View.SYSTEM_UI_FLAG_LAYOUT_STABLE
    144.                                     | View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR);
    145.                         } else {
    146.                             window.getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
    147.                                     | View.SYSTEM_UI_FLAG_LAYOUT_STABLE);
    148.                         }
    149.  
    150.  
    151.                     } else {
    152.                         //留出来状态栏 不留出来导航栏 没找到办法。。
    153.                         return;
    154.                     }
    155.                 }
    156.             } else {
    157.                 View decor = activity.getWindow().getDecorView();
    158.                 if (isDarkStatusBarIcon && Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
    159.                     decor.setSystemUiVisibility(View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR);
    160.                 } else {
    161.                     // We want to change tint color to white again.
    162.                     // You can also record the flags in advance so that you can turn UI back completely if
    163.                     // you have set other flags before, such as translucent or full screen.
    164.                     decor.setSystemUiVisibility(0);
    165.                 }
    166.             }
    167.         } catch (Exception e) {
    168.         }
    169.     }
    170.  
    171.     private static void initStatusBarStyle(Activity activity, boolean isMarginStatusBar
    172.             , boolean isMarginNavigationBar) {
    173.         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
    174.             if (isMarginStatusBar && isMarginNavigationBar) {
    175.                 activity.getWindow().getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_STABLE);
    176.             } else if (!isMarginStatusBar && !isMarginNavigationBar) {
    177.                 activity.getWindow().getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
    178.                         | View.SYSTEM_UI_FLAG_LAYOUT_STABLE);
    179.             } else if (!isMarginStatusBar && isMarginNavigationBar) {
    180.  
    181.                 activity.getWindow().getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
    182.                         | View.SYSTEM_UI_FLAG_LAYOUT_STABLE);
    183.             } else {
    184.                 //留出来状态栏 不留出来导航栏 没找到办法。。
    185.             }
    186.         }
    187.  
    188.     }
    189. }
    1. package com.iflytek.jzapp.utils.immersive;
    2.  
    3. import android.annotation.SuppressLint;
    4. import android.annotation.TargetApi;
    5. import android.app.Activity;
    6. import android.content.Context;
    7. import android.content.res.Configuration;
    8. import android.content.res.Resources;
    9. import android.graphics.Point;
    10. import android.os.Build;
    11. import android.provider.Settings;
    12. import android.util.DisplayMetrics;
    13. import android.view.View;
    14. import android.view.ViewGroup;
    15. import android.view.Window;
    16. import android.view.WindowManager;
    17.  
    18. /**
    19.  * @author：luck
    20.  * @date：2021/11/17 11:48 上午
    21.  * @describe：DensityUtil
    22.  */
    23. public class DensityUtil {
    24.     /**
    25.      * 获取屏幕真实宽度
    26.      *
    27.      * @param context
    28.      * @return
    29.      */
    30.     public static int getRealScreenWidth(Context context) {
    31.         WindowManager wm = (WindowManager) context.getApplicationContext().getSystemService(Context.WINDOW_SERVICE);
    32.         Point point = new Point();
    33.         wm.getDefaultDisplay().getRealSize(point);
    34.         return point.x;
    35.     }
    36.  
    37.     /**
    38.      * 获取屏幕真实高度
    39.      *
    40.      * @param context
    41.      * @return
    42.      */
    43.     public static int getRealScreenHeight(Context context) {
    44.         WindowManager wm = (WindowManager) context.getApplicationContext().getSystemService(Context.WINDOW_SERVICE);
    45.         Point point = new Point();
    46.         wm.getDefaultDisplay().getRealSize(point);
    47.         return point.y;
    48.     }
    49.  
    50.  
    51.     /**
    52.      * 获取屏幕高度(不包含状态栏高度)
    53.      *
    54.      * @param context
    55.      * @return
    56.      */
    57.     public static int getScreenHeight(Context context) {
    58.         return getRealScreenHeight(context) - getStatusNavigationBarHeight(context);
    59.     }
    60.  
    61.     /**
    62.      * 获取状态栏和导航栏高度
    63.      *
    64.      * @param context
    65.      * @return
    66.      */
    67.     private static int getStatusNavigationBarHeight(Context context) {
    68.         if (isNavBarVisible(context)) {
    69.             return getStatusBarHeight(context) + getNavigationBarHeight(context);
    70.         } else {
    71.             return getStatusBarHeight(context);
    72.         }
    73.     }
    74.  
    75.     /**
    76.      * 获取状态栏高度
    77.      */
    78.     public static int getStatusBarHeight(Context context) {
    79.         int result = 0;
    80.         int resourceId = Resources.getSystem().getIdentifier("status_bar_height", "dimen", "android");
    81.         if (resourceId > 0) {
    82.             result = context.getResources().getDimensionPixelSize(resourceId);
    83.         }
    84.         return result == 0 ? dip2px(context, 26) : result;
    85.     }
    86.  
    87.  
    88.     /**
    89.      * Return whether the navigation bar visible.
    90.      * <p>Call it in onWindowFocusChanged will get right result.</p>
    91.      *
    92.      * @param
    93.      * @return {@code true}: yes<br>{@code false}: no
    94.      */
    95.     public static boolean isNavBarVisible(Context context) {
    96.         boolean isVisible = false;
    97.         if (!(context instanceof Activity)) {
    98.             return false;
    99.         }
    100.         Activity activity = (Activity) context;
    101.         Window window = activity.getWindow();
    102.         ViewGroup decorView = (ViewGroup) window.getDecorView();
    103.         for (int i = 0, count = decorView.getChildCount(); i < count; i++) {
    104.             final View child = decorView.getChildAt(i);
    105.             final int id = child.getId();
    106.             if (id != View.NO_ID) {
    107.                 String resourceEntryName = getResNameById(activity, id);
    108.                 if ("navigationBarBackground".equals(resourceEntryName)
    109.                         && child.getVisibility() == View.VISIBLE) {
    110.                     isVisible = true;
    111.                     break;
    112.                 }
    113.             }
    114.         }
    115.         if (isVisible) {
    116.             // 对于三星手机，android10以下非OneUI2的版本，比如 s8，note8 等设备上，
    117.             // 导航栏显示存在bug："当用户隐藏导航栏时显示输入法的时候导航栏会跟随显示"，会导致隐藏输入法之后判断错误
    118.             // 这个问题在 OneUI 2 & android 10 版本已修复
    119.             if (RomUtils.isSamsung()
    120.                     && Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1
    121.                     && Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
    122.                 try {
    123.                     return Settings.Global.getInt(activity.getContentResolver(), "navigationbar_hide_bar_enabled") == 0;
    124.                 } catch (Exception ignore) {
    125.                 }
    126.             }
    127.  
    128.             int visibility = decorView.getSystemUiVisibility();
    129.             isVisible = (visibility & View.SYSTEM_UI_FLAG_HIDE_NAVIGATION) == 0;
    130.         }
    131.  
    132.         return isVisible;
    133.     }
    134.  
    135.     /**
    136.      * getResNameById
    137.      *
    138.      * @param context
    139.      * @param id
    140.      * @return
    141.      */
    142.     private static String getResNameById(Context context, int id) {
    143.         try {
    144.             return context.getResources().getResourceEntryName(id);
    145.         } catch (Exception ignore) {
    146.             return "";
    147.         }
    148.     }
    149.  
    150.  
    151.     /**
    152.      * 获取导航栏宽度
    153.      *
    154.      * @param context
    155.      * @return
    156.      */
    157.     @TargetApi(14)
    158.     public static int getNavigationBarWidth(Context context) {
    159.         int result = 0;
    160.         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
    161.             if (isNavBarVisible(context)) {
    162.                 return getInternalDimensionSize(context, "navigation_bar_width");
    163.             }
    164.         }
    165.         return result;
    166.     }
    167.  
    168.     /**
    169.      * 获取导航栏高度
    170.      *
    171.      * @param context
    172.      * @return
    173.      */
    174.     @TargetApi(14)
    175.     public static int getNavigationBarHeight(Context context) {
    176.         int result = 0;
    177.         Resources res = context.getResources();
    178.         boolean mInPortrait = (res.getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT);
    179.         if (isNavBarVisible(context)) {
    180.             String key;
    181.             if (mInPortrait) {
    182.                 key = "navigation_bar_height";
    183.             } else {
    184.                 key = "navigation_bar_height_landscape";
    185.             }
    186.             return getInternalDimensionSize(context, key);
    187.         }
    188.         return result;
    189.     }
    190.  
    191.  
    192.     private static int getInternalDimensionSize(Context context, String key) {
    193.         int result = 0;
    194.         try {
    195.             int resourceId = Resources.getSystem().getIdentifier(key, "dimen", "android");
    196.             if (resourceId > 0) {
    197.                 int sizeOne = context.getResources().getDimensionPixelSize(resourceId);
    198.                 int sizeTwo = Resources.getSystem().getDimensionPixelSize(resourceId);
    199.  
    200.                 if (sizeTwo >= sizeOne) {
    201.                     return sizeTwo;
    202.                 } else {
    203.                     float densityOne = context.getResources().getDisplayMetrics().density;
    204.                     float densityTwo = Resources.getSystem().getDisplayMetrics().density;
    205.                     float f = sizeOne * densityTwo / densityOne;
    206.                     return (int) ((f >= 0) ? (f + 0.5f) : (f - 0.5f));
    207.                 }
    208.             }
    209.         } catch (Resources.NotFoundException ignored) {
    210.             return 0;
    211.         }
    212.         return result;
    213.     }
    214.  
    215.     @SuppressLint("NewApi")
    216.     private static float getSmallestWidthDp(Activity activity) {
    217.         DisplayMetrics metrics = new DisplayMetrics();
    218.         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
    219.             activity.getWindowManager().getDefaultDisplay().getRealMetrics(metrics);
    220.         } else {
    221.             activity.getWindowManager().getDefaultDisplay().getMetrics(metrics);
    222.         }
    223.         float widthDp = metrics.widthPixels / metrics.density;
    224.         float heightDp = metrics.heightPixels / metrics.density;
    225.         return Math.min(widthDp, heightDp);
    226.     }
    227.  
    228.     public static boolean isNavigationAtBottom(Activity activity) {
    229.         Resources res = activity.getResources();
    230.         boolean mInPortrait = (res.getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT);
    231.         return (getSmallestWidthDp(activity) >= 600 || mInPortrait);
    232.     }
    233.  
    234.     /**
    235.      * dp2px
    236.      */
    237.     public static int dip2px(Context context, float dpValue) {
    238.         final float scale = context.getApplicationContext().getResources().getDisplayMetrics().density;
    239.         return (int) (dpValue * scale + 0.5f);
    240.     }
    241. }
    1. package com.iflytek.jzapp.utils.immersive;
    2.  
    3. import android.os.Build;
    4. import android.text.TextUtils;
    5.  
    6.  
    7. import java.io.BufferedReader;
    8. import java.io.IOException;
    9. import java.io.InputStreamReader;
    10. import java.util.regex.Pattern;
    11.  
    12. /**
    13.  * @author：luck
    14.  * @data：2018/3/28 下午1:02
    15.  * @描述: Rom版本管理
    16.  */
    17.  
    18. public class RomUtils {
    19.  
    20.     private static final String[] ROM_SAMSUNG = {"samsung"};
    21.     private final static String UNKNOWN = "unknown";
    22.  
    23.     public static class AvailableRomType {
    24.         public static final int MIUI = 1;
    25.         public static final int FLYME = 2;
    26.         public static final int ANDROID_NATIVE = 3;
    27.         public static final int NA = 4;
    28.     }
    29.  
    30.  
    31.     private static Integer romType;
    32.  
    33.     public static int getLightStatausBarAvailableRomType() {
    34.         if (romType != null) {
    35.             return romType;
    36.         }
    37.  
    38.         if (isMIUIV6OrAbove()) {
    39.             romType = AvailableRomType.MIUI;
    40.             return romType;
    41.         }
    42.  
    43.         if (isFlymeV4OrAbove()) {
    44.             romType = AvailableRomType.FLYME;
    45.             return romType;
    46.         }
    47.  
    48.         if (isAndroid5OrAbove()) {
    49.             romType = AvailableRomType.ANDROID_NATIVE;
    50.             return romType;
    51.         }
    52.  
    53.         romType = AvailableRomType.NA;
    54.         return romType;
    55.     }
    56.  
    57.     //Flyme V4的displayId格式为 [Flyme OS 4.x.x.xA]
    58.     //Flyme V5的displayId格式为 [Flyme 5.x.x.x beta]
    59.     private static boolean isFlymeV4OrAbove() {
    60.         return (getFlymeVersion() >= 4);
    61.     }
    62.  
    63.  
    64.     //Flyme V4的displayId格式为 [Flyme OS 4.x.x.xA]
    65.     //Flyme V5的displayId格式为 [Flyme 5.x.x.x beta]
    66.     public static int getFlymeVersion() {
    67.         String displayId = Build.DISPLAY;
    68.         if (!TextUtils.isEmpty(displayId) && displayId.contains("Flyme")) {
    69.             displayId = displayId.replaceAll("Flyme", "");
    70.             displayId = displayId.replaceAll("OS", "");
    71.             displayId = displayId.replaceAll(" ", "");
    72.  
    73.  
    74.             String version = displayId.substring(0, 1);
    75.  
    76.             return stringToInt(version);
    77.         }
    78.         return 0;
    79.     }
    80.  
    81.     //MIUI V6对应的versionCode是4
    82.     //MIUI V7对应的versionCode是5
    83.     private static boolean isMIUIV6OrAbove() {
    84.         String miuiVersionCodeStr = getSystemProperty();
    85.         if (!TextUtils.isEmpty(miuiVersionCodeStr)) {
    86.             try {
    87.                 int miuiVersionCode = ValueOf.toInt(miuiVersionCodeStr);
    88.                 if (miuiVersionCode >= 4) {
    89.                     return true;
    90.                 }
    91.             } catch (Exception e) {
    92.                 e.printStackTrace();
    93.             }
    94.         }
    95.         return false;
    96.     }
    97.  
    98.  
    99.     public static int getMIUIVersionCode() {
    100.         String miuiVersionCodeStr = getSystemProperty();
    101.         int miuiVersionCode = 0;
    102.         if (!TextUtils.isEmpty(miuiVersionCodeStr)) {
    103.             try {
    104.                 miuiVersionCode = ValueOf.toInt(miuiVersionCodeStr);
    105.                 return miuiVersionCode;
    106.             } catch (Exception e) {
    107.                 e.printStackTrace();
    108.             }
    109.         }
    110.         return miuiVersionCode;
    111.     }
    112.  
    113.  
    114.     //Android Api 23以上
    115.     private static boolean isAndroid5OrAbove() {
    116.         return Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP;
    117.     }
    118.  
    119.  
    120.     private static String getSystemProperty() {
    121.         String line;
    122.         BufferedReader input = null;
    123.         try {
    124.             Process p = Runtime.getRuntime().exec("getprop " + "ro.miui.ui.version.code");
    125.             input = new BufferedReader(new InputStreamReader(p.getInputStream()), 1024);
    126.             line = input.readLine();
    127.             input.close();
    128.         } catch (IOException ex) {
    129.             return null;
    130.         } finally {
    131.             if (input != null) {
    132.                 try {
    133.                     input.close();
    134.                 } catch (IOException e) {
    135.                     e.printStackTrace();
    136.                 }
    137.             }
    138.         }
    139.         return line;
    140.     }
    141.  
    142.     /**
    143.      * Return whether the rom is made by samsung.
    144.      *
    145.      * @return {@code true}: yes<br>{@code false}: no
    146.      */
    147.     public static boolean isSamsung() {
    148.         final String brand = getBrand();
    149.         final String manufacturer = getManufacturer();
    150.         return isRightRom(brand, manufacturer, ROM_SAMSUNG);
    151.     }
    152.  
    153.     private static boolean isRightRom(final String brand, final String manufacturer, final String... names) {
    154.         for (String name : names) {
    155.             if (brand.contains(name) || manufacturer.contains(name)) {
    156.                 return true;
    157.             }
    158.         }
    159.         return false;
    160.     }
    161.  
    162.     private static String getManufacturer() {
    163.         try {
    164.             String manufacturer = Build.MANUFACTURER;
    165.             if (!TextUtils.isEmpty(manufacturer)) {
    166.                 return manufacturer.toLowerCase();
    167.             }
    168.         } catch (Throwable ignore) {/**/}
    169.         return UNKNOWN;
    170.     }
    172.     private static String getBrand() {
    173.         try {
    174.             String brand = Build.BRAND;
    175.             if (!TextUtils.isEmpty(brand)) {
    176.                 return brand.toLowerCase();
    177.             }
    178.         } catch (Throwable ignore) {/**/}
    179.         return UNKNOWN;
    180.     }
    181.  
    182.     /**
    183.      * 匹配数值
    184.      *
    185.      * @param str
    186.      * @return
    187.      */
    188.     public static int stringToInt(String str) {
    189.         Pattern pattern = Pattern.compile("^[-\\+]?[\\d]+$");
    190.         return pattern.matcher(str).matches() ? ValueOf.toInt(str) : 0;
    191.     }
    192.  
    193. }
    1. package com.iflytek.jzapp.utils.immersive;
    2.  
    3. /**
    4.  * @author：luck
    5.  * @date：2019-11-12 14:27
    6.  * @describe：类型转换工具类
    7.  */
    8. public class ValueOf {
    9.     public static String toString(Object o) {
    10.         String value = "";
    11.         try {
    12.             value = o.toString();
    13.         } catch (Exception e) {
    14.         }
    15.  
    16.         return value;
    17.     }
    18.  
    19.  
    20.     public static double toDouble(Object o) {
    21.  
    22.         return toDouble(o, 0);
    23.     }
    24.  
    25.     public static double toDouble(Object o, int defaultValue) {
    26.         if (o == null) {
    27.             return defaultValue;
    28.         }
    29.  
    30.         double value;
    31.         try {
    32.             value = Double.parseDouble(o.toString().trim());
    33.         } catch (Exception e) {
    34.             value = defaultValue;
    35.         }
    36.  
    37.         return value;
    38.     }
    39.  
    40.     public static long toLong(Object o, long defaultValue) {
    41.         if (o == null) {
    42.             return defaultValue;
    43.         }
    44.         long value = 0;
    45.         try {
    46.             String s = o.toString().trim();
    47.             if (s.contains(".")) {
    48.                 value = Long.parseLong(s.substring(0, s.lastIndexOf(".")));
    49.             } else {
    50.                 value = Long.parseLong(s);
    51.             }
    52.         } catch (Exception e) {
    53.             value = defaultValue;
    54.         }
    55.  
    56.  
    57.         return value;
    58.     }
    59.  
    60.     public static long toLong(Object o) {
    61.         return toLong(o, 0);
    62.     }
    63.  
    64.  
    65.     public static float toFloat(Object o, long defaultValue) {
    66.         if (o == null) {
    67.             return defaultValue;
    68.         }
    69.         float value = 0;
    70.         try {
    71.             String s = o.toString().trim();
    72.             value = Float.parseFloat(s);
    73.         } catch (Exception e) {
    74.             value = defaultValue;
    75.         }
    76.  
    77.  
    78.         return value;
    79.     }
    80.  
    81.     public static float toFloat(Object o) {
    82.         return toFloat(o, 0);
    83.     }
    84.  
    85.  
    86.     public static int toInt(Object o, int defaultValue) {
    87.         if (o == null) {
    88.             return defaultValue;
    89.         }
    90.         int value;
    91.         try {
    92.             String s = o.toString().trim();
    93.             if (s.contains(".")) {
    94.                 value = Integer.parseInt(s.substring(0, s.lastIndexOf(".")));
    95.             } else {
    96.                 value = Integer.parseInt(s);
    97.             }
    98.         } catch (Exception e) {
    99.             value = defaultValue;
    100.         }
    101.  
    102.         return value;
    103.     }
    104.  
    105.     public static int toInt(Object o) {
    106.         return toInt(o, 0);
    107.     }
    108.  
    109.     public static boolean toBoolean(Object o) {
    110.         return toBoolean(o, false);
    111.  
    112.     }
    113.  
    114.  
    115.     public static boolean toBoolean(Object o, boolean defaultValue) {
    116.         if (o == null) {
    117.             return false;
    118.         }
    119.         boolean value;
    120.         try {
    121.             String s = o.toString().trim();
    122.             if ("false".equals(s.trim())) {
    123.                 value =  false;
    124.             } else {
    125.                 value =  true;
    126.             }
    127.         } catch (Exception e) {
    128.             value = defaultValue;
    129.         }
    130.  
    131.         return value;
    132.     }
    133.  
    134.  
    135.     public static <T> T to(Object o, T defaultValue) {
    136.         if (o == null) {
    137.             return defaultValue;
    138.         }
    139.         T value = (T)o;
    140.         return (T) value;
    141.     }
    142. }

  • 相关阅读:
    李沐动手学深度学习V2-BERT预训练和代码实现
    玩转SpringBoot：动态排除Starter配置，轻松部署
    idea打包项目，使用maven
    python每日一题【剑指 Offer 12. 矩阵中的路径】
    基于FPGA的图像高斯滤波实现,包括tb测试文件和MATLAB辅助验证
    【JAVA程序设计】基于SSM的电影院在线购票系统-沙箱支付
    springboot（12）：@ControllerAdvice和@RestControllerAdvice注解使用
    LeetCode，回溯算法
    【Mysql】子查询
    10.10 翻译设置
  • 原文地址：https://blog.csdn.net/qq_26331411/article/details/125424231