Android自定义状态栏颜色与APP风格保持一致的实现方法

theme.holo.light.noactionbar.translucentdecor
theme.holo.noactionbar.translucentdecor
<style name="apptheme" parent="appbasetheme"> 
<!-- status bar --> 
<item name="android:windowtranslucentstatus">true</item> 
<!-- navigation bar --> 
<item name="android:windowtranslucentnavigation">true</item> 
</style>

@override 
protected void oncreate(bundle savedinstancestate) { 
super.oncreate(savedinstancestate); 
if (build.version.sdk_int >= build.version_codes.kitkat) { 
settranslucentstatus(true); 
systembartintmanager tintmanager = new systembartintmanager(this); 
tintmanager.setstatusbartintenabled(true); 
tintmanager.setstatusbartintresource(r.color.top_bg_color);//通知栏所需颜色 
} 
setcontentview(r.layout.main_activity); 
} 
@targetapi(19) 
private void settranslucentstatus(boolean on) { 
window win = getwindow(); 
windowmanager.layoutparams winparams = win.getattributes(); 
final int bits = windowmanager.layoutparams.flag_translucent_status; 
if (on) { 
winparams.flags |= bits; 
} else { 
winparams.flags &= ~bits; 
} 
win.setattributes(winparams); 
}

import android.annotation.suppresslint; 
import android.annotation.targetapi; 
import android.app.activity; 
import android.content.context; 
import android.content.res.configuration; 
import android.content.res.resources; 
import android.content.res.typedarray; 
import android.graphics.drawable.drawable; 
import android.os.build; 
import android.util.displaymetrics; 
import android.util.typedvalue; 
import android.view.gravity; 
import android.view.view; 
import android.view.viewconfiguration; 
import android.view.viewgroup; 
import android.view.window; 
import android.view.windowmanager; 
import android.widget.framelayout.layoutparams; 
import java.lang.reflect.method; 
/** 
* class to manage status and navigation bar tint effects when using kitkat 
* translucent system ui modes. 
* 
*/ 
@suppresswarnings({ "rawtypes", "unchecked" }) 
public class systembartintmanager { 
static { 
// android allows a system property to override the presence of the navigation bar. 
// used by the emulator. 
// see https://github.com/android/platform_frameworks_base/blob/master/policy/src/com/android/internal/policy/impl/phonewindowmanager.java#l1076 
if (build.version.sdk_int >= build.version_codes.kitkat) { 
try { 
class c = class.forname("android.os.systemproperties"); 
method m = c.getdeclaredmethod("get", string.class); 
m.setaccessible(true); 
snavbaroverride = (string) m.invoke(null, "qemu.hw.mainkeys"); 
} catch (throwable e) { 
snavbaroverride = null; 
} 
} 
} 
/** 
* the default system bar tint color value. 
*/ 
public static final int default_tint_color = 0x99000000; 
private static string snavbaroverride; 
private final systembarconfig mconfig; 
private boolean mstatusbaravailable; 
private boolean mnavbaravailable; 
private boolean mstatusbartintenabled; 
private boolean mnavbartintenabled; 
private view mstatusbartintview; 
private view mnavbartintview; 
/** 
* constructor. call this in the host activity oncreate method after its 
* content view has been set. you should always create new instances when 
* the host activity is recreated. 
* 
* @param activity the host activity. 
*/ 
@targetapi(19) 
public systembartintmanager(activity activity) { 
window win = activity.getwindow(); 
viewgroup decorviewgroup = (viewgroup) win.getdecorview(); 
if (build.version.sdk_int >= build.version_codes.kitkat) { 
// check theme attrs 
int[] attrs = {android.r.attr.windowtranslucentstatus, 
android.r.attr.windowtranslucentnavigation}; 
typedarray a = activity.obtainstyledattributes(attrs); 
try { 
mstatusbaravailable = a.getboolean(0, false); 
mnavbaravailable = a.getboolean(1, false); 
} finally { 
a.recycle(); 
} 
// check window flags 
windowmanager.layoutparams winparams = win.getattributes(); 
int bits = windowmanager.layoutparams.flag_translucent_status; 
if ((winparams.flags & bits) != 0) { 
mstatusbaravailable = true; 
} 
bits = windowmanager.layoutparams.flag_translucent_navigation; 
if ((winparams.flags & bits) != 0) { 
mnavbaravailable = true; 
} 
} 
mconfig = new systembarconfig(activity, mstatusbaravailable, mnavbaravailable); 
// device might not have virtual navigation keys 
if (!mconfig.hasnavigtionbar()) { 
mnavbaravailable = false; 
} 
if (mstatusbaravailable) { 
setupstatusbarview(activity, decorviewgroup); 
} 
if (mnavbaravailable) { 
setupnavbarview(activity, decorviewgroup); 
} 
} 
/** 
* enable tinting of the system status bar. 
* 
* if the platform is running jelly bean or earlier, or translucent system 
* ui modes have not been enabled in either the theme or via window flags, 
* then this method does nothing. 
* 
* @param enabled true to enable tinting, false to disable it (default). 
*/ 
public void setstatusbartintenabled(boolean enabled) { 
mstatusbartintenabled = enabled; 
if (mstatusbaravailable) { 
mstatusbartintview.setvisibility(enabled ? view.visible : view.gone); 
} 
} 
/** 
* enable tinting of the system navigation bar. 
* 
* if the platform does not have soft navigation keys, is running jelly bean 
* or earlier, or translucent system ui modes have not been enabled in either 
* the theme or via window flags, then this method does nothing. 
* 
* @param enabled true to enable tinting, false to disable it (default). 
*/ 
public void setnavigationbartintenabled(boolean enabled) { 
mnavbartintenabled = enabled; 
if (mnavbaravailable) { 
mnavbartintview.setvisibility(enabled ? view.visible : view.gone); 
} 
} 
/** 
* apply the specified color tint to all system ui bars. 
* 
* @param color the color of the background tint. 
*/ 
public void settintcolor(int color) { 
setstatusbartintcolor(color); 
setnavigationbartintcolor(color); 
} 
/** 
* apply the specified drawable or color resource to all system ui bars. 
* 
* @param res the identifier of the resource. 
*/ 
public void settintresource(int res) { 
setstatusbartintresource(res); 
setnavigationbartintresource(res); 
} 
/** 
* apply the specified drawable to all system ui bars. 
* 
* @param drawable the drawable to use as the background, or null to remove it. 
*/ 
public void settintdrawable(drawable drawable) { 
setstatusbartintdrawable(drawable); 
setnavigationbartintdrawable(drawable); 
} 
/** 
* apply the specified alpha to all system ui bars. 
* 
* @param alpha the alpha to use 
*/ 
public void settintalpha(float alpha) { 
setstatusbaralpha(alpha); 
setnavigationbaralpha(alpha); 
} 
/** 
* apply the specified color tint to the system status bar. 
* 
* @param color the color of the background tint. 
*/ 
public void setstatusbartintcolor(int color) { 
if (mstatusbaravailable) { 
mstatusbartintview.setbackgroundcolor(color); 
} 
} 
/** 
* apply the specified drawable or color resource to the system status bar. 
* 
* @param res the identifier of the resource. 
*/ 
public void setstatusbartintresource(int res) { 
if (mstatusbaravailable) { 
mstatusbartintview.setbackgroundresource(res); 
} 
} 
/** 
* apply the specified drawable to the system status bar. 
* 
* @param drawable the drawable to use as the background, or null to remove it. 
*/ 
@suppresswarnings("deprecation") 
public void setstatusbartintdrawable(drawable drawable) { 
if (mstatusbaravailable) { 
mstatusbartintview.setbackgrounddrawable(drawable); 
} 
} 
/** 
* apply the specified alpha to the system status bar. 
* 
* @param alpha the alpha to use 
*/ 
@targetapi(11) 
public void setstatusbaralpha(float alpha) { 
if (mstatusbaravailable && build.version.sdk_int >= build.version_codes.honeycomb) { 
mstatusbartintview.setalpha(alpha); 
} 
} 
/** 
* apply the specified color tint to the system navigation bar. 
* 
* @param color the color of the background tint. 
*/ 
public void setnavigationbartintcolor(int color) { 
if (mnavbaravailable) { 
mnavbartintview.setbackgroundcolor(color); 
} 
} 
/** 
* apply the specified drawable or color resource to the system navigation bar. 
* 
* @param res the identifier of the resource. 
*/ 
public void setnavigationbartintresource(int res) { 
if (mnavbaravailable) { 
mnavbartintview.setbackgroundresource(res); 
} 
} 
/** 
* apply the specified drawable to the system navigation bar. 
* 
* @param drawable the drawable to use as the background, or null to remove it. 
*/ 
@suppresswarnings("deprecation") 
public void setnavigationbartintdrawable(drawable drawable) { 
if (mnavbaravailable) { 
mnavbartintview.setbackgrounddrawable(drawable); 
} 
} 
/** 
* apply the specified alpha to the system navigation bar. 
* 
* @param alpha the alpha to use 
*/ 
@targetapi(11) 
public void setnavigationbaralpha(float alpha) { 
if (mnavbaravailable && build.version.sdk_int >= build.version_codes.honeycomb) { 
mnavbartintview.setalpha(alpha); 
} 
} 
/** 
* get the system bar configuration. 
* 
* @return the system bar configuration for the current device configuration. 
*/ 
public systembarconfig getconfig() { 
return mconfig; 
} 
/** 
* is tinting enabled for the system status bar? 
* 
* @return true if enabled, false otherwise. 
*/ 
public boolean isstatusbartintenabled() { 
return mstatusbartintenabled; 
} 
/** 
* is tinting enabled for the system navigation bar? 
* 
* @return true if enabled, false otherwise. 
*/ 
public boolean isnavbartintenabled() { 
return mnavbartintenabled; 
} 
private void setupstatusbarview(context context, viewgroup decorviewgroup) { 
mstatusbartintview = new view(context); 
layoutparams params = new layoutparams(layoutparams.match_parent, mconfig.getstatusbarheight()); 
params.gravity = gravity.top; 
if (mnavbaravailable && !mconfig.isnavigationatbottom()) { 
params.rightmargin = mconfig.getnavigationbarwidth(); 
} 
mstatusbartintview.setlayoutparams(params); 
mstatusbartintview.setbackgroundcolor(default_tint_color); 
mstatusbartintview.setvisibility(view.gone); 
decorviewgroup.addview(mstatusbartintview); 
} 
private void setupnavbarview(context context, viewgroup decorviewgroup) { 
mnavbartintview = new view(context); 
layoutparams params; 
if (mconfig.isnavigationatbottom()) { 
params = new layoutparams(layoutparams.match_parent, mconfig.getnavigationbarheight()); 
params.gravity = gravity.bottom; 
} else { 
params = new layoutparams(mconfig.getnavigationbarwidth(), layoutparams.match_parent); 
params.gravity = gravity.right; 
} 
mnavbartintview.setlayoutparams(params); 
mnavbartintview.setbackgroundcolor(default_tint_color); 
mnavbartintview.setvisibility(view.gone); 
decorviewgroup.addview(mnavbartintview); 
} 
/** 
* class which describes system bar sizing and other characteristics for the current 
* device configuration. 
* 
*/ 
public static class systembarconfig { 
private static final string status_bar_height_res_name = "status_bar_height"; 
private static final string nav_bar_height_res_name = "navigation_bar_height"; 
private static final string nav_bar_height_landscape_res_name = "navigation_bar_height_landscape"; 
private static final string nav_bar_width_res_name = "navigation_bar_width"; 
private static final string show_nav_bar_res_name = "config_shownavigationbar"; 
private final boolean mtranslucentstatusbar; 
private final boolean mtranslucentnavbar; 
private final int mstatusbarheight; 
private final int mactionbarheight; 
private final boolean mhasnavigationbar; 
private final int mnavigationbarheight; 
private final int mnavigationbarwidth; 
private final boolean minportrait; 
private final float msmallestwidthdp; 
private systembarconfig(activity activity, boolean translucentstatusbar, boolean traslucentnavbar) { 
resources res = activity.getresources(); 
minportrait = (res.getconfiguration().orientation == configuration.orientation_portrait); 
msmallestwidthdp = getsmallestwidthdp(activity); 
mstatusbarheight = getinternaldimensionsize(res, status_bar_height_res_name); 
mactionbarheight = getactionbarheight(activity); 
mnavigationbarheight = getnavigationbarheight(activity); 
mnavigationbarwidth = getnavigationbarwidth(activity); 
mhasnavigationbar = (mnavigationbarheight > 0); 
mtranslucentstatusbar = translucentstatusbar; 
mtranslucentnavbar = traslucentnavbar; 
} 
@targetapi(14) 
private int getactionbarheight(context context) { 
int result = 0; 
if (build.version.sdk_int >= build.version_codes.ice_cream_sandwich) { 
typedvalue tv = new typedvalue(); 
context.gettheme().resolveattribute(android.r.attr.actionbarsize, tv, true); 
result = typedvalue.complextodimensionpixelsize(tv.data, context.getresources().getdisplaymetrics()); 
} 
return result; 
} 
@targetapi(14) 
private int getnavigationbarheight(context context) { 
resources res = context.getresources(); 
int result = 0; 
if (build.version.sdk_int >= build.version_codes.ice_cream_sandwich) { 
if (hasnavbar(context)) { 
string key; 
if (minportrait) { 
key = nav_bar_height_res_name; 
} else { 
key = nav_bar_height_landscape_res_name; 
} 
return getinternaldimensionsize(res, key); 
} 
} 
return result; 
} 
@targetapi(14) 
private int getnavigationbarwidth(context context) { 
resources res = context.getresources(); 
int result = 0; 
if (build.version.sdk_int >= build.version_codes.ice_cream_sandwich) { 
if (hasnavbar(context)) { 
return getinternaldimensionsize(res, nav_bar_width_res_name); 
} 
} 
return result; 
} 
@targetapi(14) 
private boolean hasnavbar(context context) { 
resources res = context.getresources(); 
int resourceid = res.getidentifier(show_nav_bar_res_name, "bool", "android"); 
if (resourceid != 0) { 
boolean hasnav = res.getboolean(resourceid); 
// check override flag (see static block) 
if ("1".equals(snavbaroverride)) { 
hasnav = false; 
} else if ("0".equals(snavbaroverride)) { 
hasnav = true; 
} 
return hasnav; 
} else { // fallback 
return !viewconfiguration.get(context).haspermanentmenukey(); 
} 
} 
private int getinternaldimensionsize(resources res, string key) { 
int result = 0; 
int resourceid = res.getidentifier(key, "dimen", "android"); 
if (resourceid > 0) { 
result = res.getdimensionpixelsize(resourceid); 
} 
return result; 
} 
@suppresslint("newapi") 
private float getsmallestwidthdp(activity activity) { 
displaymetrics metrics = new displaymetrics(); 
if (build.version.sdk_int >= build.version_codes.jelly_bean) { 
activity.getwindowmanager().getdefaultdisplay().getrealmetrics(metrics); 
} else { 
// todo this is not correct, but we don't really care pre-kitkat 
activity.getwindowmanager().getdefaultdisplay().getmetrics(metrics); 
} 
float widthdp = metrics.widthpixels / metrics.density; 
float heightdp = metrics.heightpixels / metrics.density; 
return math.min(widthdp, heightdp); 
} 
/** 
* should a navigation bar appear at the bottom of the screen in the current 
* device configuration? a navigation bar may appear on the right side of 
* the screen in certain configurations. 
* 
* @return true if navigation should appear at the bottom of the screen, false otherwise. 
*/ 
public boolean isnavigationatbottom() { 
return (msmallestwidthdp >= 600 || minportrait); 
} 
/** 
* get the height of the system status bar. 
* 
* @return the height of the status bar (in pixels). 
*/ 
public int getstatusbarheight() { 
return mstatusbarheight; 
} 
/** 
* get the height of the action bar. 
* 
* @return the height of the action bar (in pixels). 
*/ 
public int getactionbarheight() { 
return mactionbarheight; 
} 
/** 
* does this device have a system navigation bar? 
* 
* @return true if this device uses soft key navigation, false otherwise. 
*/ 
public boolean hasnavigtionbar() { 
return mhasnavigationbar; 
} 
/** 
* get the height of the system navigation bar. 
* 
* @return the height of the navigation bar (in pixels). if the device does not have 
* soft navigation keys, this will always return 0. 
*/ 
public int getnavigationbarheight() { 
return mnavigationbarheight; 
} 
/** 
* get the width of the system navigation bar when it is placed vertically on the screen. 
* 
* @return the width of the navigation bar (in pixels). if the device does not have 
* soft navigation keys, this will always return 0. 
*/ 
public int getnavigationbarwidth() { 
return mnavigationbarwidth; 
} 
/** 
* get the layout inset for any system ui that appears at the top of the screen. 
* 
* @param withactionbar true to include the height of the action bar, false otherwise. 
* @return the layout inset (in pixels). 
*/ 
public int getpixelinsettop(boolean withactionbar) { 
return (mtranslucentstatusbar ? mstatusbarheight : 0) + (withactionbar ? mactionbarheight : 0); 
} 
/** 
* get the layout inset for any system ui that appears at the bottom of the screen. 
* 
* @return the layout inset (in pixels). 
*/ 
public int getpixelinsetbottom() { 
if (mtranslucentnavbar && isnavigationatbottom()) { 
return mnavigationbarheight; 
} else { 
return 0; 
} 
} 
/** 
* get the layout inset for any system ui that appears at the right of the screen. 
* 
* @return the layout inset (in pixels). 
*/ 
public int getpixelinsetright() { 
if (mtranslucentnavbar && !isnavigationatbottom()) { 
return mnavigationbarwidth; 
} else { 
return 0; 
} 
} 
} 
}

if (build.version.sdk_int >= build.version_codes.kitkat) { 
((linearlayout)findviewbyid(r.id.ll)).setpadding(0, sysutils.getstatusheight(this), 0,0); 
}

/** 
* 状态栏高度算法 
* @param activity 
* @return 
*/ 
public static int getstatusheight(activity activity){ 
int statusheight = 0; 
rect localrect = new rect(); 
activity.getwindow().getdecorview().getwindowvisibledisplayframe(localrect); 
statusheight = localrect.top; 
if (0 == statusheight){ 
class<?> localclass; 
try { 
localclass = class.forname("com.android.internal.r$dimen"); 
object localobject = localclass.newinstance(); 
int i5 = integer.parseint(localclass.getfield("status_bar_height").get(localobject).tostring()); 
statusheight = activity.getresources().getdimensionpixelsize(i5); 
} catch (classnotfoundexception e) { 
e.printstacktrace(); 
} catch (illegalaccessexception e) { 
e.printstacktrace(); 
} catch (instantiationexception e) { 
e.printstacktrace(); 
} catch (numberformatexception e) { 
e.printstacktrace(); 
} catch (illegalargumentexception e) { 
e.printstacktrace(); 
} catch (securityexception e) { 
e.printstacktrace(); 
} catch (nosuchfieldexception e) { 
e.printstacktrace(); 
} 
} 
return statusheight; 
}