Android进阶之路 - 顶部状态栏、底部虚拟导航栏相关操作

快过年了，2018希望我们每个人都健康，开心，同时继续上进 ！

2020补充：基本包含了我几年在开发中用到的关于顶部状态栏和底部导航栏的绝大部分功能 ~

2024 补充：以前写的都能算是源代码，有时候可能兼容不足，有兴趣的可以直接用 immersionBar，后续有时间的话我也会在单写一篇该框架的项目使用

顶部状态栏

状态栏是否可见

    public static boolean isStatusBarShown(Activity context) {
        WindowManager.LayoutParams params = context.getWindow().getAttributes();
        int paramsFlag = params.flags & (~WindowManager.LayoutParams.FLAG_FULLSCREEN);
        return paramsFlag == params.flags;
    }

获取状态栏高度

    public static int getStatusBarHeight(Context context) {
        Resources resources = context.getResources();
        int resourceId = resources.getIdentifier("status_bar_height", "dimen", "android");
        int height = resources.getDimensionPixelSize(resourceId);
        return height;
    }

隐藏状态栏

   //取消标题
   requestWindowFeature(Window.FEATURE_NO_TITLE);
   //取消状态栏
   getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
           WindowManager.LayoutParams.FLAG_FULLSCREEN);
   //切记：上方设置需要放在setContentView之前！不然会报错且不生效！
   setContentView(R.layout.activity_main);

显示状态栏

   // 隐藏状态栏
   // getWindow().addFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN);
   // 显示状态栏
   getWindow().clearFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN);
   //切记：上方设置需要放在setContentView之前！不然会报错且不生效！
   setContentView(R.layout.activity_main);

设置透明状态栏 (需要在setContentView之前调用，部分手机可能会出现一个淡色的遮罩层)

   if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
            //透明状态栏
            getWindow().addFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS);
    }

设置透明状态栏，无淡灰色遮罩层（显示的白字，底部背景是layout的背景图或背景色，没有处理底部灰色遮罩层）

   if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            //透明状态栏
            getWindow().addFlags(WindowManager.LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS);
            getWindow().clearFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS);
            getWindow().addFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_NAVIGATION);
            getWindow().setStatusBarColor(Color.parseColor("#00000000"));
        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
            getWindow().addFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS);
    }

设置透明状态栏，顶部与底部无淡灰色遮罩层（完整版）

      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            //透明状态栏
            getWindow().addFlags(WindowManager.LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS);
            getWindow().clearFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS);
            int option = View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
                    | View.SYSTEM_UI_FLAG_LAYOUT_STABLE;
            getWindow().getDecorView().setSystemUiVisibility(option);
            getWindow().setStatusBarColor(Color.parseColor("#00000000"));
        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
            getWindow().addFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS);
        }

设置状态栏背景底色、显示字体色

白底黑字

   if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            //android版本>=6.0 设置白底黑字状态栏
            Window window = getWindow();
            window.addFlags(WindowManager.LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS);
          
            window.setStatusBarColor(getResources().getColor(android.R.color.white));
            window.getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR);
     }

黑底白字

    public static void setStatusTitle(Activity activity){
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            activity.getWindow().getDecorView().setSystemUiVisibility( View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN|View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR);
        }
     }

Tip 俩种设置状态栏背景色与字体颜色的方法，本质没差别(使用之后，当第二个参数设置为true时，均设置状态栏字体颜色为深色；反之为浅色)

方式一

设置状态栏图标为深色和魅族特定的文字风格

/**
     * 设置状态栏图标为深色和魅族特定的文字风格
     * 可以用来判断是否为Flyme用户
     * @param activity 需要设置的窗口
     * @param dark 是否把状态栏字体及图标颜色设置为深色
     * @return  boolean 成功执行返回true
     *
     */
    public static boolean FlymeSetStatusBarLightMode(Activity activity, boolean dark) {
        boolean result = false;
        if (activity != null) {
            try {
                WindowManager.LayoutParams lp = activity.getWindow().getAttributes();
                Field darkFlag = WindowManager.LayoutParams.class
                        .getDeclaredField("MEIZU_FLAG_DARK_STATUS_BAR_ICON");
                Field meizuFlags = WindowManager.LayoutParams.class
                        .getDeclaredField("meizuFlags");
                darkFlag.setAccessible(true);
                meizuFlags.setAccessible(true);
                int bit = darkFlag.getInt(null);
                int value = meizuFlags.getInt(lp);
                if (dark) {
                    value |= bit;
                } else {
                    value &= ~bit;
                }
                meizuFlags.setInt(lp, value);
                activity.getWindow().setAttributes(lp);
                result = true;
            } catch (Exception e) {

            }
        }
        return result;
    }

设置状态栏字体图标为深色，需要 MIUIV6 以上

/**
     * 设置状态栏字体图标为深色，需要MIUIV6以上
     * @param activity 需要设置的窗口
     * @param dark 是否把状态栏字体及图标颜色设置为深色
     * @return  boolean 成功执行返回true
     *
     */
    public static boolean MIUISetStatusBarLightMode(Activity activity, boolean dark) {
        boolean result = false;
        if (activity != null) {
            Class clazz = activity.getClass();
            try {
                int darkModeFlag = 0;
                Class layoutParams = Class.forName("android.view.MiuiWindowManager$LayoutParams");
                Field  field = layoutParams.getField("EXTRA_FLAG_STATUS_BAR_DARK_MODE");
                darkModeFlag = field.getInt(layoutParams);
                Method extraFlagField = clazz.getMethod("setExtraFlags", int.class, int.class);
                if(dark){
                    extraFlagField.invoke(activity,darkModeFlag,darkModeFlag);//状态栏透明且黑色字体
                }else{
                    extraFlagField.invoke(activity, 0, darkModeFlag);//清除黑色字体
                }
                result=true;
            }catch (Exception e){

            }
        }
        return result;
    }

方式二（项目中已使用 - 没问题）

MIUI6+设置成白色的背景，字体颜色为黑色

/**
     * MIUI6+设置成白色的背景，字体颜色为黑色。
     **/
    public boolean setMiuiStatusBarDarkMode(Activity activity, boolean darkmode) {
        Class<? extends Window> clazz = activity.getWindow().getClass();
        try {
            int darkModeFlag = 0;
            Class<?> layoutParams = Class.forName("android.view.MiuiWindowManager$LayoutParams");
            Field field = layoutParams.getField("EXTRA_FLAG_STATUS_BAR_DARK_MODE");
            darkModeFlag = field.getInt(layoutParams);
            Method extraFlagField = clazz.getMethod("setExtraFlags", int.class, int.class);
            extraFlagField.invoke(activity.getWindow(), darkmode ? darkModeFlag : 0, darkModeFlag);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

Flyme4+设置成白色的背景，字体颜色为黑色

 /**
     * Flyme4+设置成白色的背景，字体颜色为黑色。
     **/
    public boolean setMeizuStatusBarDarkIcon(Activity activity, boolean dark) {
        boolean result = false;
        if (activity != null) {
            try {
                WindowManager.LayoutParams lp = activity.getWindow().getAttributes();
                Field darkFlag = WindowManager.LayoutParams.class
                        .getDeclaredField("MEIZU_FLAG_DARK_STATUS_BAR_ICON");
                Field meizuFlags = WindowManager.LayoutParams.class
                        .getDeclaredField("meizuFlags");
                darkFlag.setAccessible(true);
                meizuFlags.setAccessible(true);
                int bit = darkFlag.getInt(null);
                int value = meizuFlags.getInt(lp);
                if (dark) {
                    value |= bit;
                } else {
                    value &= ~bit;
                }
                meizuFlags.setInt(lp, value);
                activity.getWindow().setAttributes(lp);
                result = true;
            } catch (Exception e) {
            }
        }
        return result;
    }

---

底部虚拟导航栏

是否存在虚拟按键

注意：指的是当前手机是否设置有虚拟按键！而不是指虚拟按键是否显示！

 public static boolean isHaveSoftKey(Activity activity) {
     Display d = activity.getWindowManager().getDefaultDisplay();
     DisplayMetrics realDisplayMetrics = new DisplayMetrics();
     d.getRealMetrics(realDisplayMetrics);
     int realHeight = realDisplayMetrics.heightPixels;
     int realWidth = realDisplayMetrics.widthPixels;
     DisplayMetrics displayMetrics = new DisplayMetrics();
     d.getMetrics(displayMetrics);
     int displayHeight = displayMetrics.heightPixels;
     int displayWidth = displayMetrics.widthPixels;
     return (realWidth - displayWidth) > 0 || (realHeight - displayHeight) > 0;
 }

底部虚拟按键的高度

 public static int getBottomSoftKeysHeight(Activity activity) {
     Display d = activity.getWindowManager().getDefaultDisplay();
     DisplayMetrics realDisplayMetrics = new DisplayMetrics();
     d.getRealMetrics(realDisplayMetrics);
     int realHeight = realDisplayMetrics.heightPixels;
     DisplayMetrics displayMetrics = new DisplayMetrics();
     d.getMetrics(displayMetrics);
     int displayHeight = displayMetrics.heightPixels;
     return (realHeight - displayHeight);
 }

隐藏、显示 - 底部虚拟导航栏

    /**
     * @param state   true 隐藏  false 还原显示
     */
    public static void hideBottomMenu(Context context,boolean state){
        Intent barIntent = new Intent();
        barIntent.setAction("com.alf.switch_status_bar");
        barIntent.putExtra("hide", state);
        context.sendBroadcast(barIntent);
    }

隐藏 - 底部虚拟导航栏

    private void hideBottomMenu() {
        int flags = View.SYSTEM_UI_FLAG_HIDE_NAVIGATION |
                View.SYSTEM_UI_FLAG_FULLSCREEN |
                View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION |
                View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY |
                View.SYSTEM_UI_FLAG_LAYOUT_STABLE |
                View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN;
        View decorView = getWindow().getDecorView();
        decorView.setSystemUiVisibility(flags);
    }

隐藏 - 底部虚拟导航栏（支持划出）

隐藏底部虚拟按键，但是如果你在底部网上滑动还是显示的出来的

    private void hideBottomMenu() {
        //android 隐藏底部虚拟按键
        //隐藏虚拟按键，并且全屏
        if (Build.VERSION.SDK_INT > 11 && Build.VERSION.SDK_INT < 19) { // lower api
            View v = this.getWindow().getDecorView();
            v.setSystemUiVisibility(View.GONE);
        } else if (Build.VERSION.SDK_INT >= 19) {
            //for new api versions.
            View decorView = getWindow().getDecorView();
            int uiOptions = View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
                    | View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY
                    | View.SYSTEM_UI_FLAG_FULLSCREEN;
            decorView.setSystemUiVisibility(uiOptions);
        }
    }

监听 - 底部导航的显示状态

主要实现思想就是首先动态监听屏幕变化，同时在动态监听内监听屏幕的实际高度变化，可用有个关键的是屏幕的真实高度，真实高度代码了一个最大高度，当实际高度=最大高度时就证明了底部导航的显示，反之就是底部导航的隐藏 ~

关于这个功能我在网上找了很多半成品，大部分都无效，所幸拼拼凑凑实现了此项功能，亲测可用！

先来一个半成品中的BaseActivity，其主要目的是动态监听屏幕的一个变化！

NavigationActivity
建议：可以将NavigationActivity的关键代码移植到我们项目的BaseActivity，同时此类中的一些Log完全可以删掉，这里打Log只是为了看一些执行流程 ~

package nk.com.bottomnavigation;

import android.app.Activity;
import android.os.Bundle;
import android.util.Log;
import android.view.ViewTreeObserver;
import android.widget.FrameLayout;

/**
 * @author MrLiu
 * @date 2020/9/14
 * desc
 */
public class NavigationActivity extends Activity implements ViewTreeObserver.OnGlobalLayoutListener {
    FrameLayout content;
    private static final String TAG = "BaseActivityForAuto";
    private boolean mLayoutComplete = false;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        content = (FrameLayout) findViewById(android.R.id.content);
        content.post(new Runnable() {
            @Override
            public void run() {
                mLayoutComplete = true;
                Log.e(TAG, "content 布局完成");
            }
        });
        content.getViewTreeObserver().addOnGlobalLayoutListener(NavigationActivity.this);
    }

    @Override
    protected void onPause() {
        super.onPause();
        Log.e(TAG, "super.onPause();");
    }

    @Override
    protected void onResume() {
        super.onResume();
        Log.e(TAG, "super.onResume();");
    }

    @Override
    public void onGlobalLayout() {
        Log.e(TAG, "onGlobalLayout");
        if (!mLayoutComplete)
            return;
        onNavigationBarStatusChanged();
    }

    protected void onNavigationBarStatusChanged() {
        // 子类重写该方法，实现自己的逻辑即可。
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        content.getViewTreeObserver().removeOnGlobalLayoutListener(this);
    }
}

MainActivity
此处的MainActivity替代到对应的需求类即可，但是要记得继承上方的父类 - - ~

package nk.com.bottomnavigation;

import android.content.Context;
import android.os.Build;
import android.os.Bundle;
import android.util.DisplayMetrics;
import android.util.Log;
import android.view.Display;
import android.view.WindowManager;

public class MainActivity extends NavigationActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }

    @Override
    protected void onNavigationBarStatusChanged() {
        super.onNavigationBarStatusChanged();
        
        int displayHeight = getHeight();
        int basicHeight = getRealHeight();
        Log.e("tag", "高度" + displayHeight);
        Log.e("tag", "真实高度" + basicHeight);
        if (displayHeight < basicHeight) {
            Log.e("tag", "底部导航显示");
        } else {
            Log.e("tag", "底部导航隐藏");
        }
    }

	//屏幕高度
    public int getHeight() {
        DisplayMetrics dm = new DisplayMetrics();
        WindowManager windowManager = (WindowManager) MainActivity.this.getSystemService(Context.WINDOW_SERVICE);
        windowManager.getDefaultDisplay().getMetrics(dm);
        return dm.heightPixels;
    }

	//真实高度
    public int getRealHeight() {
        WindowManager windowManager = (WindowManager) MainActivity.this.getSystemService(Context.WINDOW_SERVICE);
        Display display = windowManager.getDefaultDisplay();
        DisplayMetrics dm = new DisplayMetrics();
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
            display.getRealMetrics(dm);
        } else {
            display.getMetrics(dm);
        }
        int realHeight = dm.heightPixels;
        return realHeight;
    }
}

禁用 - 底部虚拟导航栏

现在很多Andorid机型可以自定义底部导航的作用 ~

主要借鉴于此，在此做个笔记，无此需求，请忽略！未曾亲自尝试过！

这样做的话，整个系统都是禁用掉底部导航栏的，可能会影响其他软件的使用，非特定需求请不要使用

• 工具准备

Root精灵手机安装包（该连接已不可用，自行查找可行安装包）：http://www.shuame.com/root/

RE文件管理器：http://shouji.baidu.com/software/22415959.html

通过上面链接下载两个工具，一个是获取设备的root（不要担心，这不是刷机，不会让设备变砖头。而且操作简单，一键root），一个是root之后查看、修改设备文件

• Root

在Android设备（手机、平板都可以）安装Root精灵后，打开它，主界面有个“一键root”的大大的按钮，点击它，等待几分钟，就root成功啦！

• 修改系统文件，彻底禁用虚拟导航栏（不用担心，只改一处地方，不麻烦也不难）

安装RE文件管理器，打开它，进入system目录下，找到 build.prop 这个文件；

长按这个文件，在弹出的菜单（或者顶部optionMenu中）选择用“文本编辑器打开”；

在末尾处加一行命令：qemu.hw.mainkeys=1

然后点击菜单“保存并退出”；

最后，重启设备即可生效

---

三方工具类

StatusBarUtil（功能繁多，适用性强）

核心 StatusBarUtil 源码 ，源码太长就不在该篇记录了…

简单使用方法可以前往 该处，如有需求也可以去Git-StatusBarUtil

• 准备

build 引入：

  compile 'com.jaeger.statusbarutil:library:1.4.0'

• 使用

设置状态栏颜色

 StatusBarUtil.setColor(this, ContextCompat.getColor(this,R.color.colorAccent));

设置状态栏透明

 StatusBarUtil.setTranslucent(this);

---

ScreenUtils（功能较弱，支持获取相关组件高度的业务场景）

主要用于获取屏幕高度，适用于含 或 不含 状态栏、导航栏相关组件的关联高度（代码较少，可直接看）

package com.cari.promo.diskon.util;

import android.app.Activity;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Rect;
import android.util.DisplayMetrics;
import android.view.Display;
import android.view.View;
import android.view.WindowManager;

import java.lang.reflect.Method;

public class ScreenUtils {
    private ScreenUtils() {
        /* cannot be instantiated */
        throw new UnsupportedOperationException("cannot be instantiated");
    }

    /**
     * 获得屏幕高度
     *
     * @param context
     * @return
     */
    public static int getScreenWidth(Context context) {
        WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
        DisplayMetrics outMetrics = new DisplayMetrics();
        wm.getDefaultDisplay().getMetrics(outMetrics);
        return outMetrics.widthPixels;
    }

    /**
     * 获得屏幕宽度
     *
     * @param context
     * @return
     */
    public static int getScreenHeight(Context context) {
        WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
        DisplayMetrics outMetrics = new DisplayMetrics();
        wm.getDefaultDisplay().getMetrics(outMetrics);
        return outMetrics.heightPixels;
    }

    /**
     * 获得状态栏的高度
     *
     * @param context
     * @return
     */
    public static int getStatusHeight(Context context) {

        int statusHeight = -1;
        try {
            Class<?> clazz = Class.forName("com.android.internal.R$dimen");
            Object object = clazz.newInstance();
            int height = Integer.parseInt(clazz.getField("status_bar_height").get(object).toString());
            statusHeight = context.getResources().getDimensionPixelSize(height);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return statusHeight;
    }

    /**
     * 获取当前屏幕截图，包含状态栏
     *
     * @param activity
     * @return
     */
    public static Bitmap snapShotWithStatusBar(Activity activity) {
        View view = activity.getWindow().getDecorView();
        view.setDrawingCacheEnabled(true);
        view.buildDrawingCache();
        Bitmap bmp = view.getDrawingCache();
        int width = getScreenWidth(activity);
        int height = getScreenHeight(activity);
        Bitmap bp = null;
        bp = Bitmap.createBitmap(bmp, 0, 0, width, height);
        view.destroyDrawingCache();
        return bp;

    }

    /**
     * 获取当前屏幕截图，不包含状态栏
     *
     * @param activity
     * @return
     */
    public static Bitmap snapShotWithoutStatusBar(Activity activity) {
        View view = activity.getWindow().getDecorView();
        view.setDrawingCacheEnabled(true);
        view.buildDrawingCache();
        Bitmap bmp = view.getDrawingCache();
        Rect frame = new Rect();
        activity.getWindow().getDecorView().getWindowVisibleDisplayFrame(frame);
        int statusBarHeight = frame.top;

        int width = getScreenWidth(activity);
        int height = getScreenHeight(activity);
        Bitmap bp = null;
        bp = Bitmap.createBitmap(bmp, 0, statusBarHeight, width, height - statusBarHeight);
        view.destroyDrawingCache();
        return bp;
    }

    /**
     * 获取 虚拟按键的高度
     *
     * @param context 上下文
     * @return 虚拟键高度
     */
    public static int getBottomStatusHeight(Context context) {
        int totalHeight = getAbsoluteHeight(context);

        int contentHeight = getScreenHeight(context);

        return totalHeight - contentHeight;
    }

    /**
     * 获取屏幕原始尺寸高度，包括虚拟功能键高度
     *
     * @param context 上下文
     * @return The absolute height of the available display size in pixels.
     */
    private static int getAbsoluteHeight(Context context) {
        int absoluteHeight = 0;
        WindowManager windowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
        Display display = null;
        if (windowManager != null) {
            display = windowManager.getDefaultDisplay();
        }
        DisplayMetrics displayMetrics = new DisplayMetrics();
        @SuppressWarnings("rawtypes") Class c;
        try {
            c = Class.forName("android.view.Display");
            @SuppressWarnings("unchecked") Method method = c.getMethod("getRealMetrics", DisplayMetrics.class);
            method.invoke(display, displayMetrics);
            absoluteHeight = displayMetrics.heightPixels;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return absoluteHeight;
    }
}

---

课堂补习

获取手机屏幕高度

 public int getHeight() {
     DisplayMetrics dm = new DisplayMetrics();
     WindowManager windowManager = (WindowManager) MainActivity.this.getSystemService(Context.WINDOW_SERVICE);
     windowManager.getDefaultDisplay().getMetrics(dm);
     return dm.heightPixels;
 }

获取屏幕真实高度（包括虚拟键盘）

 public int getRealHeight() {
     WindowManager windowManager = (WindowManager) MainActivity.this.getSystemService(Context.WINDOW_SERVICE);
     Display display = windowManager.getDefaultDisplay();
     DisplayMetrics dm = new DisplayMetrics();
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
         display.getRealMetrics(dm);
     } else {
         display.getMetrics(dm);
     }
     int realHeight = dm.heightPixels;
     return realHeight;
 }

控制状态栏和导航栏显示

控制状态栏显示，Activity的主题中配置全屏属性

<item name="android:windowFullscreen">true</item>

扩展部分，借鉴它处，当作笔记

View.SYSTEM_UI_FLAG_LAYOUT_STABLE：全屏显示时保证尺寸不变。
View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN：Activity全屏显示，状态栏显示在Activity页面上面。
View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION：效果同View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
View.SYSTEM_UI_FLAG_HIDE_NAVIGATION：隐藏导航栏
View.SYSTEM_UI_FLAG_FULLSCREEN：Activity全屏显示，且状态栏被隐藏覆盖掉。
View.SYSTEM_UI_FLAG_VISIBLE：Activity非全屏显示，显示状态栏和导航栏。
View.INVISIBLE：Activity伸展全屏显示，隐藏状态栏。
View.SYSTEM_UI_LAYOUT_FLAGS：效果同View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY：必须配合View.SYSTEM_UI_FLAG_FULLSCREEN和View.SYSTEM_UI_FLAG_HIDE_NAVIGATION组合使用，达到的效果是拉出状态栏和导航栏后显示一会儿消失。

// 全屏展示
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
        // 全屏显示，隐藏状态栏和导航栏，拉出状态栏和导航栏显示一会儿后消失。
        activity.getWindow().getDecorView().setSystemUiVisibility(
                View.SYSTEM_UI_FLAG_LAYOUT_STABLE
                        | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
                        | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
                        | View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
                        | View.SYSTEM_UI_FLAG_FULLSCREEN
                        | View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY);
    } else {
        // 全屏显示，隐藏状态栏
        activity.getWindow().getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_FULLSCREEN);
    }
}

// 非全屏显示，显示状态栏和导航栏
activity.getWindow().getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_VISIBLE);