安卓实现沉浸式效果，状态栏变色

  2. 原创作品，未经允许禁止转载，转载请注明来自：http://www.cnblogs.com/jiangbeixiaoqiao/
  4. <span style="font-size:24px;">这几天研究沉浸模式，多种方法，目前觉得今天的这种方法最靠谱，android4.4以上都可以实现此效果，个人感觉并不是沉浸模式，原理只是将状态栏更改了颜色，且加上了半透明效果，而且效果和QQ等基本一样。  
  5. 1.调用如下代码  
  6. if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT){  
  7.            getWindow().addFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS);  
  8.            getWindow().addFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_NAVIGATION);  
  9.            SystemBarTintManager tintManager = new SystemBarTintManager(this);  
  10.            tintManager.setStatusBarTintColor(getResources().getColor(R.color.pink));  
  11.            tintManager.setStatusBarTintEnabled(true);  
  12. 2.在布局文件的跟布局中添加如下属性  
  13. android:fitsSystemWindows="true"  
  14. 或者更改主题 stytle  
  15. <item name="android:fitsSystemWindows">true</item>  
  16. 3.导入SystemBarTintManager 类  
  17.   
  18.   
  19. package cn.doolii.usershopping.base;  
  20.   
  21.   
  22. import android.annotation.SuppressLint;  
  23. import android.annotation.TargetApi;  
  24. import android.app.Activity;  
  25. import android.content.Context;  
  26. import android.content.res.Configuration;  
  27. import android.content.res.Resources;  
  28. import android.content.res.TypedArray;  
  29. import android.graphics.drawable.Drawable;  
  30. import android.os.Build;  
  31. import android.util.DisplayMetrics;  
  32. import android.util.TypedValue;  
  33. import android.view.Gravity;  
  34. import android.view.View;  
  35. import android.view.ViewConfiguration;  
  36. import android.view.ViewGroup;  
  37. import android.view.Window;  
  38. import android.view.WindowManager;  
  39. import android.widget.FrameLayout.LayoutParams;  
  40.   
  41.   
  42. import java.lang.reflect.Method;  
  43.   
  44.   
  45. /** 
  46.  * Class to manage status and navigation bar tint effects when using KitKat  
  47.  * translucent system UI modes. 
  48.  * 
  49.  */  
  50. public class SystemBarTintManager {  
  51.   
  52.   
  53.     static {  
  54.         // Android allows a system property to override the presence of the navigation bar.  
  55.         // Used by the emulator.  
  56.         // See https://github.com/android/platform_frameworks_base/blob/master/policy/src/com/android/internal/policy/impl/PhoneWindowManager.java#L1076  
  57.         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {  
  58.             try {  
  59.                 Class c = Class.forName("android.os.SystemProperties");  
  60.                 Method m = c.getDeclaredMethod("get", String.class);  
  61.                 m.setAccessible(true);  
  62.                 sNavBarOverride = (String) m.invoke(null, "qemu.hw.mainkeys");  
  63.             } catch (Throwable e) {  
  64.                 sNavBarOverride = null;  
  65.             }  
  66.         }  
  67.     }  
  68.   
  69.   
  70.   
  71.   
  72.     /** 
  73.      * The default system bar tint color value. 
  74.      */  
  75.     public static final int DEFAULT_TINT_COLOR = 0x99000000;  
  76.   
  77.   
  78.     private static String sNavBarOverride;  
  79.   
  80.   
  81.     private final SystemBarConfig mConfig;  
  82.     private boolean mStatusBarAvailable;  
  83.     private boolean mNavBarAvailable;  
  84.     private boolean mStatusBarTintEnabled;  
  85.     private boolean mNavBarTintEnabled;  
  86.     private View mStatusBarTintView;  
  87.     private View mNavBarTintView;  
  88.   
  89.   
  90.     /** 
  91.      * Constructor. Call this in the host activity onCreate method after its 
  92.      * content view has been set. You should always create new instances when 
  93.      * the host activity is recreated. 
  94.      * 
  95.      * @param activity The host activity. 
  96.      */  
  97.     @TargetApi(19)  
  98.     public SystemBarTintManager(Activity activity) {  
  99.   
  100.   
  101.         Window win = activity.getWindow();  
  102.         ViewGroup decorViewGroup = (ViewGroup) win.getDecorView();  
  103.   
  104.   
  105.         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {  
  106.             // check theme attrs  
  107.             int[] attrs = {android.R.attr.windowTranslucentStatus,  
  108.                     android.R.attr.windowTranslucentNavigation};  
  109.             TypedArray a = activity.obtainStyledAttributes(attrs);  
  110.             try {  
  111.                 mStatusBarAvailable = a.getBoolean(0, false);  
  112.                 mNavBarAvailable = a.getBoolean(1, false);  
  113.             } finally {  
  114.                 a.recycle();  
  115.             }  
  116.   
  117.   
  118.             // check window flags  
  119.             WindowManager.LayoutParams winParams = win.getAttributes();  
  120.             int bits = WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS;  
  121.             if ((winParams.flags & bits) != 0) {  
  122.                 mStatusBarAvailable = true;  
  123.             }  
  124.             bits = WindowManager.LayoutParams.FLAG_TRANSLUCENT_NAVIGATION;  
  125.             if ((winParams.flags & bits) != 0) {  
  126.                 mNavBarAvailable = true;  
  127.             }  
  128.         }  
  129.   
  130.   
  131.         mConfig = new SystemBarConfig(activity, mStatusBarAvailable, mNavBarAvailable);  
  132.         // device might not have virtual navigation keys  
  133.         if (!mConfig.hasNavigtionBar()) {  
  134.             mNavBarAvailable = false;  
  135.         }  
  136.   
  137.   
  138.         if (mStatusBarAvailable) {  
  139.             setupStatusBarView(activity, decorViewGroup);  
  140.         }  
  141.         if (mNavBarAvailable) {  
  142.             setupNavBarView(activity, decorViewGroup);  
  143.         }  
  144.   
  145.   
  146.     }  
  147.   
  148.   
  149.     /** 
  150.      * Enable tinting of the system status bar. 
  151.      * 
  152.      * If the platform is running Jelly Bean or earlier, or translucent system 
  153.      * UI modes have not been enabled in either the theme or via window flags, 
  154.      * then this method does nothing. 
  155.      * 
  156.      * @param enabled True to enable tinting, false to disable it (default). 
  157.      */  
  158.     public void setStatusBarTintEnabled(boolean enabled) {  
  159.         mStatusBarTintEnabled = enabled;  
  160.         if (mStatusBarAvailable) {  
  161.             mStatusBarTintView.setVisibility(enabled ? View.VISIBLE : View.GONE);  
  162.         }  
  163.     }  
  164.   
  165.   
  166.     /** 
  167.      * Enable tinting of the system navigation bar. 
  168.      * 
  169.      * If the platform does not have soft navigation keys, is running Jelly Bean 
  170.      * or earlier, or translucent system UI modes have not been enabled in either 
  171.      * the theme or via window flags, then this method does nothing. 
  172.      * 
  173.      * @param enabled True to enable tinting, false to disable it (default). 
  174.      */  
  175.     public void setNavigationBarTintEnabled(boolean enabled) {  
  176.         mNavBarTintEnabled = enabled;  
  177.         if (mNavBarAvailable) {  
  178.             mNavBarTintView.setVisibility(enabled ? View.VISIBLE : View.GONE);  
  179.         }  
  180.     }  
  181.   
  182.   
  183.     /** 
  184.      * Apply the specified color tint to all system UI bars. 
  185.      * 
  186.      * @param color The color of the background tint. 
  187.      */  
  188.     public void setTintColor(int color) {  
  189.         setStatusBarTintColor(color);  
  190.         setNavigationBarTintColor(color);  
  191.     }  
  192.   
  193.   
  194.     /** 
  195.      * Apply the specified drawable or color resource to all system UI bars. 
  196.      * 
  197.      * @param res The identifier of the resource. 
  198.      */  
  199.     public void setTintResource(int res) {  
  200.         setStatusBarTintResource(res);  
  201.         setNavigationBarTintResource(res);  
  202.     }  
  203.   
  204.   
  205.     /** 
  206.      * Apply the specified drawable to all system UI bars. 
  207.      * 
  208.      * @param drawable The drawable to use as the background, or null to remove it. 
  209.      */  
  210.     public void setTintDrawable(Drawable drawable) {  
  211.         setStatusBarTintDrawable(drawable);  
  212.         setNavigationBarTintDrawable(drawable);  
  213.     }  
  214.   
  215.   
  216.     /** 
  217.      * Apply the specified alpha to all system UI bars. 
  218.      * 
  219.      * @param alpha The alpha to use 
  220.      */  
  221.     public void setTintAlpha(float alpha) {  
  222.         setStatusBarAlpha(alpha);  
  223.         setNavigationBarAlpha(alpha);  
  224.     }  
  225.   
  226.   
  227.     /** 
  228.      * Apply the specified color tint to the system status bar. 
  229.      * 
  230.      * @param color The color of the background tint. 
  231.      */  
  232.     public void setStatusBarTintColor(int color) {  
  233.         if (mStatusBarAvailable) {  
  234.             mStatusBarTintView.setBackgroundColor(color);  
  235.         }  
  236.     }  
  237.   
  238.   
  239.     /** 
  240.      * Apply the specified drawable or color resource to the system status bar. 
  241.      * 
  242.      * @param res The identifier of the resource. 
  243.      */  
  244.     public void setStatusBarTintResource(int res) {  
  245.         if (mStatusBarAvailable) {  
  246.             mStatusBarTintView.setBackgroundResource(res);  
  247.         }  
  248.     }  
  249.   
  250.   
  251.     /** 
  252.      * Apply the specified drawable to the system status bar. 
  253.      * 
  254.      * @param drawable The drawable to use as the background, or null to remove it. 
  255.      */  
  256.     @SuppressWarnings("deprecation")  
  257.     public void setStatusBarTintDrawable(Drawable drawable) {  
  258.         if (mStatusBarAvailable) {  
  259.             mStatusBarTintView.setBackgroundDrawable(drawable);  
  260.         }  
  261.     }  
  262.   
  263.   
  264.     /** 
  265.      * Apply the specified alpha to the system status bar. 
  266.      * 
  267.      * @param alpha The alpha to use 
  268.      */  
  269.     @TargetApi(11)  
  270.     public void setStatusBarAlpha(float alpha) {  
  271.         if (mStatusBarAvailable && Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {  
  272.             mStatusBarTintView.setAlpha(alpha);  
  273.         }  
  274.     }  
  275.   
  276.   
  277.     /** 
  278.      * Apply the specified color tint to the system navigation bar. 
  279.      * 
  280.      * @param color The color of the background tint. 
  281.      */  
  282.     public void setNavigationBarTintColor(int color) {  
  283.         if (mNavBarAvailable) {  
  284.             mNavBarTintView.setBackgroundColor(color);  
  285.         }  
  286.     }  
  287.   
  288.   
  289.     /** 
  290.      * Apply the specified drawable or color resource to the system navigation bar. 
  291.      * 
  292.      * @param res The identifier of the resource. 
  293.      */  
  294.     public void setNavigationBarTintResource(int res) {  
  295.         if (mNavBarAvailable) {  
  296.             mNavBarTintView.setBackgroundResource(res);  
  297.         }  
  298.     }  
  299.   
  300.   
  301.     /** 
  302.      * Apply the specified drawable to the system navigation bar. 
  303.      * 
  304.      * @param drawable The drawable to use as the background, or null to remove it. 
  305.      */  
  306.     @SuppressWarnings("deprecation")  
  307.     public void setNavigationBarTintDrawable(Drawable drawable) {  
  308.         if (mNavBarAvailable) {  
  309.             mNavBarTintView.setBackgroundDrawable(drawable);  
  310.         }  
  311.     }  
  312.   
  313.   
  314.     /** 
  315.      * Apply the specified alpha to the system navigation bar. 
  316.      * 
  317.      * @param alpha The alpha to use 
  318.      */  
  319.     @TargetApi(11)  
  320.     public void setNavigationBarAlpha(float alpha) {  
  321.         if (mNavBarAvailable && Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {  
  322.             mNavBarTintView.setAlpha(alpha);  
  323.         }  
  324.     }  
  325.   
  326.   
  327.     /** 
  328.      * Get the system bar configuration. 
  329.      * 
  330.      * @return The system bar configuration for the current device configuration. 
  331.      */  
  332.     public SystemBarConfig getConfig() {  
  333.         return mConfig;  
  334.     }  
  335.   
  336.   
  337.     /** 
  338.      * Is tinting enabled for the system status bar? 
  339.      * 
  340.      * @return True if enabled, False otherwise. 
  341.      */  
  342.     public boolean isStatusBarTintEnabled() {  
  343.         return mStatusBarTintEnabled;  
  344.     }  
  345.   
  346.   
  347.     /** 
  348.      * Is tinting enabled for the system navigation bar? 
  349.      * 
  350.      * @return True if enabled, False otherwise. 
  351.      */  
  352.     public boolean isNavBarTintEnabled() {  
  353.         return mNavBarTintEnabled;  
  354.     }  
  355.   
  356.   
  357.     private void setupStatusBarView(Context context, ViewGroup decorViewGroup) {  
  358.         mStatusBarTintView = new View(context);  
  359.         LayoutParams params = new LayoutParams(LayoutParams.MATCH_PARENT, mConfig.getStatusBarHeight());  
  360.         params.gravity = Gravity.TOP;  
  361.         if (mNavBarAvailable && !mConfig.isNavigationAtBottom()) {  
  362.             params.rightMargin = mConfig.getNavigationBarWidth();  
  363.         }  
  364.         mStatusBarTintView.setLayoutParams(params);  
  365.         mStatusBarTintView.setBackgroundColor(DEFAULT_TINT_COLOR);  
  366.         mStatusBarTintView.setVisibility(View.GONE);  
  367.         decorViewGroup.addView(mStatusBarTintView);  
  368.     }  
  369.   
  370.   原创作品，未经允许禁止转载，转载请注明来自：http://www.cnblogs.com/jiangbeixiaoqiao/
  371.     private void setupNavBarView(Context context, ViewGroup decorViewGroup) {  
  372.         mNavBarTintView = new View(context);  
  373.         LayoutParams params;  
  374.         if (mConfig.isNavigationAtBottom()) {  
  375.             params = new LayoutParams(LayoutParams.MATCH_PARENT, mConfig.getNavigationBarHeight());  
  376.             params.gravity = Gravity.BOTTOM;  
  377.         } else {  
  378.             params = new LayoutParams(mConfig.getNavigationBarWidth(), LayoutParams.MATCH_PARENT);  
  379.             params.gravity = Gravity.RIGHT;  
  380.         }  
  381.         mNavBarTintView.setLayoutParams(params);  
  382.         mNavBarTintView.setBackgroundColor(DEFAULT_TINT_COLOR);  
  383.         mNavBarTintView.setVisibility(View.GONE);  
  384.         decorViewGroup.addView(mNavBarTintView);  
  385.     }  
  386.   
  387.   
  388.     /** 
  389.      * Class which describes system bar sizing and other characteristics for the current 
  390.      * device configuration. 
  391.      * 
  392.      */  
  393.     public static class SystemBarConfig {  
  394.   
  395.   
  396.         private static final String STATUS_BAR_HEIGHT_RES_NAME = "status_bar_height";  
  397.         private static final String NAV_BAR_HEIGHT_RES_NAME = "navigation_bar_height";  
  398.         private static final String NAV_BAR_HEIGHT_LANDSCAPE_RES_NAME = "navigation_bar_height_landscape";  
  399.         private static final String NAV_BAR_WIDTH_RES_NAME = "navigation_bar_width";  
  400.         private static final String SHOW_NAV_BAR_RES_NAME = "config_showNavigationBar";  
  401.   
  402.   
  403.         private final boolean mTranslucentStatusBar;  
  404.         private final boolean mTranslucentNavBar;  
  405.         private final int mStatusBarHeight;  
  406.         private final int mActionBarHeight;  
  407.         private final boolean mHasNavigationBar;  
  408.         private final int mNavigationBarHeight;  
  409.         private final int mNavigationBarWidth;  
  410.         private final boolean mInPortrait;  
  411.         private final float mSmallestWidthDp;  
  412.   
  413.   
  414.         private SystemBarConfig(Activity activity, boolean translucentStatusBar, boolean traslucentNavBar) {  
  415.             Resources res = activity.getResources();  
  416.             mInPortrait = (res.getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT);  
  417.             mSmallestWidthDp = getSmallestWidthDp(activity);  
  418.             mStatusBarHeight = getInternalDimensionSize(res, STATUS_BAR_HEIGHT_RES_NAME);  
  419.             mActionBarHeight = getActionBarHeight(activity);  
  420.             mNavigationBarHeight = getNavigationBarHeight(activity);  
  421.             mNavigationBarWidth = getNavigationBarWidth(activity);  
  422.             mHasNavigationBar = (mNavigationBarHeight > 0);  
  423.             mTranslucentStatusBar = translucentStatusBar;  
  424.             mTranslucentNavBar = traslucentNavBar;  
  425.         }  
  426.   
  427.   
  428.         @TargetApi(14)  
  429.         private int getActionBarHeight(Context context) {  
  430.             int result = 0;  
  431.             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) {  
  432.                 TypedValue tv = new TypedValue();  
  433.                 context.getTheme().resolveAttribute(android.R.attr.actionBarSize, tv, true);  
  434.                 result = TypedValue.complexToDimensionPixelSize(tv.data, context.getResources().getDisplayMetrics());  
  435.             }  
  436.             return result;  
  437.         }  
  438.   
  439.   
  440.         @TargetApi(14)  
  441.         private int getNavigationBarHeight(Context context) {  
  442.             Resources res = context.getResources();  
  443.             int result = 0;  
  444.             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) {  
  445.                 if (hasNavBar(context)) {  
  446.                     String key;  
  447.                     if (mInPortrait) {  
  448.                         key = NAV_BAR_HEIGHT_RES_NAME;  
  449.                     } else {  
  450.                         key = NAV_BAR_HEIGHT_LANDSCAPE_RES_NAME;  
  451.                     }  
  452.                     return getInternalDimensionSize(res, key);  
  453.                 }  
  454.             }  
  455.             return result;  
  456.         }  
  457.   
  458.   
  459.         @TargetApi(14)  
  460.         private int getNavigationBarWidth(Context context) {  
  461.             Resources res = context.getResources();  
  462.             int result = 0;  
  463.             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) {  
  464.                 if (hasNavBar(context)) {  
  465.                     return getInternalDimensionSize(res, NAV_BAR_WIDTH_RES_NAME);  
  466.                 }  
  467.             }  
  468.             return result;  
  469.         }  
  470.   
  471.   
  472.         @TargetApi(14)  
  473.         private boolean hasNavBar(Context context) {  
  474.             Resources res = context.getResources();  
  475.             int resourceId = res.getIdentifier(SHOW_NAV_BAR_RES_NAME, "bool", "android");  
  476.             if (resourceId != 0) {  
  477.                 boolean hasNav = res.getBoolean(resourceId);  
  478.                 // check override flag (see static block)  
  479.                 if ("1".equals(sNavBarOverride)) {  
  480.                     hasNav = false;  
  481.                 } else if ("0".equals(sNavBarOverride)) {  
  482.                     hasNav = true;  
  483.                 }  
  484.                 return hasNav;  
  485.             } else { // fallback  
  486.                 return !ViewConfiguration.get(context).hasPermanentMenuKey();  
  487.             }  
  488.         }  
  489.   
  490.   
  491.         private int getInternalDimensionSize(Resources res, String key) {  
  492.             int result = 0;  
  493.             int resourceId = res.getIdentifier(key, "dimen", "android");  
  494.             if (resourceId > 0) {  
  495.                 result = res.getDimensionPixelSize(resourceId);  
  496.             }  
  497.             return result;  
  498.         }  
  499.   
  500.   
  501.         @SuppressLint("NewApi")  
  502.         private float getSmallestWidthDp(Activity activity) {  
  503.             DisplayMetrics metrics = new DisplayMetrics();  
  504.             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {  
  505.                 activity.getWindowManager().getDefaultDisplay().getRealMetrics(metrics);  
  506.             } else {  
  507.                 // TODO this is not correct, but we don't really care pre-kitkat  
  508.                 activity.getWindowManager().getDefaultDisplay().getMetrics(metrics);  
  509.             }  
  510.             float widthDp = metrics.widthPixels / metrics.density;  
  511.             float heightDp = metrics.heightPixels / metrics.density;  
  512.             return Math.min(widthDp, heightDp);  
  513.         }  
  514.   
  515.   
  516.         /** 
  517.          * Should a navigation bar appear at the bottom of the screen in the current 
  518.          * device configuration? A navigation bar may appear on the right side of 
  519.          * the screen in certain configurations. 
  520.          * 
  521.          * @return True if navigation should appear at the bottom of the screen, False otherwise. 
  522.          */  
  523.         public boolean isNavigationAtBottom() {  
  524.             return (mSmallestWidthDp >= 600 || mInPortrait);  
  525.         }  
  526.   
  527.   
  528.         /** 
  529.          * Get the height of the system status bar. 
  530.          * 
  531.          * @return The height of the status bar (in pixels). 
  532.          */  
  533.         public int getStatusBarHeight() {  
  534.             return mStatusBarHeight;  
  535.         }  
  536.   
  537.   
  538.         /** 
  539.          * Get the height of the action bar. 
  540.          * 
  541.          * @return The height of the action bar (in pixels). 
  542.          */  
  543.         public int getActionBarHeight() {  
  544.             return mActionBarHeight;  
  545.         }  
  546.   
  547.   
  548.         /** 
  549.          * Does this device have a system navigation bar? 
  550.          * 
  551.          * @return True if this device uses soft key navigation, False otherwise. 
  552.          */  
  553.         public boolean hasNavigtionBar() {  
  554.             return mHasNavigationBar;  
  555.         }  
  556.   
  557.   
  558.         /** 
  559.          * Get the height of the system navigation bar. 
  560.          * 
  561.          * @return The height of the navigation bar (in pixels). If the device does not have 
  562.          * soft navigation keys, this will always return 0. 
  563.          */  
  564.         public int getNavigationBarHeight() {  
  565.             return mNavigationBarHeight;  
  566.         }  
  567.   
  568.   
  569.         /** 
  570.          * Get the width of the system navigation bar when it is placed vertically on the screen. 
  571.          * 
  572.          * @return The width of the navigation bar (in pixels). If the device does not have 
  573.          * soft navigation keys, this will always return 0. 
  574.          */  
  575.         public int getNavigationBarWidth() {  
  576.             return mNavigationBarWidth;  
  577.         }  
  578.   
  579.   
  580.         /** 
  581.          * Get the layout inset for any system UI that appears at the top of the screen. 
  582.          * 
  583.          * @param withActionBar True to include the height of the action bar, False otherwise. 
  584.          * @return The layout inset (in pixels). 
  585.          */  
  586.         public int getPixelInsetTop(boolean withActionBar) {  
  587.             return (mTranslucentStatusBar ? mStatusBarHeight : 0) + (withActionBar ? mActionBarHeight : 0);  
  588.         }  
  589.   
  590.   
  591.         /** 
  592.          * Get the layout inset for any system UI that appears at the bottom of the screen. 
  593.          * 
  594.          * @return The layout inset (in pixels). 
  595.          */  
  596.         public int getPixelInsetBottom() {  
  597.             if (mTranslucentNavBar && isNavigationAtBottom()) {  
  598.                 return mNavigationBarHeight;  
  599.             } else {  
  600.                 return 0;  
  601.             }  
  602.         }  
  603.   
  604.   
  605.         /** 
  606.          * Get the layout inset for any system UI that appears at the right of the screen. 
  607.          * 
  608.          * @return The layout inset (in pixels). 
  609.          */  
  610.         public int getPixelInsetRight() {  
  611.             if (mTranslucentNavBar && !isNavigationAtBottom()) {  
  612.                 return mNavigationBarWidth;  
  613.             } else {  
  614.                 return 0;  
  615.             }  
  616.         }  
  617.   
  618.   
  619.     }  
  620. 原创作品，未经允许禁止转载，转载请注明来自：http://www.cnblogs.com/jiangbeixiaoqiao/
  621.   
  622. }  
  623. </span>  
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/jiangbeixiaoqiao/p/5846427.html