Android4.4 and above can change the status bar color. Android6.0 and above can change the status bar text and icon to dark color, but MIUI and Flyme are exceptions
So we package a status bar font color based on the status bar color automatically
Method of use
override fun onCreate(savedInstanceState: Bundle?). {
super.onCreate(savedInstanceState)
// Set the status bar color
StatusBarUtils.setStatusBarLightMode(window)
}
Copy the codeSimple beep
rendering
The directory structure
Java code
StatusBarUtils
/ * * *@author lc. 2018-09-03 23:20
* @since0.6.0 * /
public class StatusBarUtils {
/** * Set the status bar text color to black **@param window window
* @paramStatusBarColor specifies the statusBarColor */
public static void setStatusBarLightMode(Window window, @ColorRes int statusBarColor) {
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
return;
}
// Result of status bar text color setting
boolean lightModeSetSuccess = true;
FitUtils.Brand brand = FitUtils.getBrand();
if (brand == FitUtils.Brand.XIAO_MI) {
// The color of the status bar
lightModeSetSuccess = setStatusBarLightModeMIUI(window, true);
} else if (brand == FitUtils.Brand.MEI_ZU) {
// Meizu status bar color
lightModeSetSuccess = setStatusBarLightModeFlyMe(window, true);
} else {
// Native mode after Android 6.0
setStatusBarLightModeOrigin(window, true);
}
if (lightModeSetSuccess) {
// The black font is set successfullysetStatusBarColor(window, statusBarColor); }}public static void setStatusBarLightMode(Window window) {
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
return;
}
// Result of status bar text color setting
boolean lightModeSetSuccess = true;
FitUtils.Brand brand = FitUtils.getBrand();
if (brand == FitUtils.Brand.XIAO_MI) {
// The color of the status bar
lightModeSetSuccess = setStatusBarLightModeMIUI(window, true);
} else if (brand == FitUtils.Brand.MEI_ZU) {
// Meizu status bar color
lightModeSetSuccess = setStatusBarLightModeFlyMe(window, true);
} else {
// Native mode after Android 6.0
setStatusBarLightModeOrigin(window, true); }}/** * Set the status bar text color to white **@param window window
* @paramStatusBarColor specifies the statusBarColor */
public static void setStatusBarDarkMode(Window window, @ColorRes int statusBarColor) {
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
return;
}
// Result of status bar text color setting
boolean darkModeSetSuccess = true;
FitUtils.Brand brand = FitUtils.getBrand();
if (brand == FitUtils.Brand.XIAO_MI) {
// The color of the status bar
darkModeSetSuccess = setStatusBarLightModeMIUI(window, false);
} else if (brand == FitUtils.Brand.MEI_ZU) {
// Meizu status bar color
darkModeSetSuccess = setStatusBarLightModeFlyMe(window, false);
} else {
// Native mode after Android 6.0
setStatusBarLightModeOrigin(window, false);
}
setStatusBarColor(window, statusBarColor);
}
/** * Change the status bar color, support 4.4 or later */
public static void setStatusBarColor(Window window, @ColorRes int colorResId) {
if (window == null) {
return;
}
if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) { window.setStatusBarColor(ResUtils.getColor(window.getContext(), colorResId)); }}/** * Change the status bar color, support 4.4 or later */
public static void setStatusBarColor(Activity activity, @ColorRes int colorResId) {
if (activity == null) {
return;
}
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
activity.getWindow().setStatusBarColor(ResUtils.getColor(activity, colorResId));
} else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
SystemBarTintManager tintManager = new SystemBarTintManager(activity);
tintManager.setStatusBarTintEnabled(true); tintManager.setStatusBarTintResource(colorResId); }}/** * Setting the status bar icon to a dark color and meizu specific text style * can be used to determine whether a Flyme user **@paramWindow Specifies the window to set@paramLightMode Specifies whether to set the status bar text and icon color to dark *@returnBoolean returns true */ on successful execution
private static boolean setStatusBarLightModeFlyMe(Window window, boolean lightMode) {
boolean result = false;
if(window ! =null) {
try {
WindowManager.LayoutParams lp = window.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 (lightMode) {
value |= bit;
} else {
value &= ~bit;
}
meizuFlags.setInt(lp, value);
window.setAttributes(lp);
result = true;
} catch(Exception e) { e.printStackTrace(); }}return result;
}
/** * Requires more than MIUIV6 **@paramLightMode Specifies whether to set the status bar text and icon color to dark *@returnBoolean returns true */ on successful execution
private static boolean setStatusBarLightModeMIUI(Window window, boolean lightMode) {
boolean result = false;
if(window ! =null) {
Class clazz = window.getClass();
try {
int lightModeFlag = 0;
Class layoutParams = Class.forName("android.view.MiuiWindowManager$LayoutParams");
Field field = layoutParams.getField("EXTRA_FLAG_STATUS_BAR_DARK_MODE");
lightModeFlag = field.getInt(layoutParams);
Method extraFlagField = clazz.getMethod("setExtraFlags".int.class, int.class);
if (lightMode) {
extraFlagField.invoke(window, lightModeFlag, lightModeFlag);// The status bar is transparent and black
} else {
extraFlagField.invoke(window, 0, lightModeFlag);// Clear the black font
}
result = true;
Development version 7.7.13 and later use the system API, the old method is invalid but does not report errors, so use the native system method to set again
setStatusBarLightModeOrigin(window, lightMode);
} catch(Exception e) { e.printStackTrace(); }}return result;
}
/** Use the native system API to set the status bar text color */
private static void setStatusBarLightModeOrigin(Window window, boolean lightMode) {
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
return;
}
View decorView = window.getDecorView();
int originVisibility = decorView.getSystemUiVisibility();
// In light color mode, use black text
if (lightMode && (originVisibility & View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR) == 0) {
originVisibility = originVisibility | View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR;
}
// Dark mode, use white text
if(! lightMode && (originVisibility & View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR) ! =0) { originVisibility = originVisibility ^ View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR; } decorView.setSystemUiVisibility(originVisibility); }}Copy the codeSystemBarTintManager
/* * Copyright (C) 2013 readyState Software Ltd * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */
/** * Class to manage status and navigation bar tint effects when using KitKat * translucent system UI modes. */
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/PhoneWindowM anager.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(a) {
return mConfig;
}
/**
* Is tinting enabled for the system status bar?
*
* @return True if enabled, False otherwise.
*/
public boolean isStatusBarTintEnabled(a) {
return mStatusBarTintEnabled;
}
/**
* Is tinting enabled for the system navigation bar?
*
* @return True if enabled, False otherwise.
*/
public boolean isNavBarTintEnabled(a) {
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;
}
returngetInternalDimensionSize(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)) {
returngetInternalDimensionSize(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(a) {
return (mSmallestWidthDp >= 600 || mInPortrait);
}
/**
* Get the height of the system status bar.
*
* @return The height of the status bar (in pixels).
*/
public int getStatusBarHeight(a) {
return mStatusBarHeight;
}
/**
* Get the height of the action bar.
*
* @return The height of the action bar (in pixels).
*/
public int getActionBarHeight(a) {
return mActionBarHeight;
}
/**
* Does this device have a system navigation bar?
*
* @return True if this device uses soft key navigation, False otherwise.
*/
public boolean hasNavigtionBar(a) {
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(a) {
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(a) {
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(a) {
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(a) {
if(mTranslucentNavBar && ! isNavigationAtBottom()) {return mNavigationBarWidth;
} else {
return 0; }}}}Copy the codeSet the color tool ResUtils
public class ResUtils {
public static int getInteger(Context context, @IntegerRes int resId) {
return context.getResources().getInteger(resId);
}
public static String getString(Context context, @StringRes int strId) {
return context.getResources().getString(strId);
}
public static String getString(Context context, @StringRes int strId, Object... formatArgs) {
return context.getResources().getString(strId, formatArgs);
}
public static int getColor(Context context, @ColorRes int colorResId) {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
return context.getColor(colorResId);
} else {
returncontext.getResources().getColor(colorResId); }}public static Drawable getDrawable(Context context, @DrawableRes int resId) {
try {
return AppCompatResources.getDrawable(context, resId);
} catch (Exception e) {
e.printStackTrace();
}
return null; }}Copy the codeMobile phone brand — FitUtils
public class FitUtils {
/** Mobile phone brand enumeration */
public enum Brand {
// Unknown brand
UNKNOWN,
/ / huawei
HUAWEI,
/ / millet
XIAO_MI,
// vivo
VIVO,
// oppo
OPPO,
/ / the meizu
MEI_ZU,
/ / samsung
SAMSUNG,
/ / nokia
NOKIA,
// Google pro son
NEXUS,
}
/** Returns the brand of the mobile system */
public static Brand getBrand(a) {
Brand brand;
String brandString = Build.BRAND;
if (TextUtils.isEmpty(brandString)) {
return Brand.UNKNOWN;
}
switch (brandString.toLowerCase()) {
case "huawei":
return Brand.HUAWEI;
case "xiaomi":
return Brand.XIAO_MI;
case "vivo":
return Brand.VIVO;
case "oppo":
return Brand.OPPO;
case "meizu":
return Brand.MEI_ZU;
case "samsung":
return Brand.SAMSUNG;
case "google":
return Brand.NEXUS;
case "nokia":
return Brand.NOKIA;
default:
returnBrand.UNKNOWN; }}/** Returns whether the phone screen has bangs */
public static boolean isWindowHasFringe(Context context) {
Brand brand = getBrand();
switch (brand) {
case XIAO_MI:
return isWindowHasFringeXiaoMi();
case OPPO:
return isWindowHasFringeOppo(context);
case VIVO:
return isWindowHasFringeVivo();
case HUAWEI:
return isWindowHasFringeHuawei(context);
default:
return false; }}/ * * * if there is a bang * https://dev.mi.com/console/doc/detail?pId=1293 * / millet mobile phone
private static boolean isWindowHasFringeXiaoMi(a) {
try{ Class<? > systemPropertiesCls = Class.forName("android.os.SystemProperties");
Method getIntMethod = systemPropertiesCls.getMethod("getInt".new Class[]{String.class, int.class});
int value = (int) getIntMethod.invoke(null."ro.miui.notch".0);
return value == 1;
} catch (Exception e) {
// no-op
}
return false;
}
/ Vivo cell phone whether there is a bang * * * * * https://swsdl.vivo.com.cn/appstore/developer/uploadfile/20180328/20180328152252602.pdf * / reference document
private static boolean isWindowHasFringeVivo(a) {
try {
Class cls = Class.forName("android.util.FtFeature");
Method method = cls.getMethod("isFeatureSupport".int.class);
return (boolean) method.invoke(null.0x00000020);
} catch (Exception e) {
// no-op
}
return false;
}
/ * * * Oppo phone whether there is a bang * * https://open.oppomobile.com/wiki/doc#id=10139 * / reference document
private static boolean isWindowHasFringeOppo(Context context) {
try {
return context.getPackageManager().hasSystemFeature("com.oppo.feature.screen.heteromorphism");
} catch (Exception e) {
// no-op
}
return false;
}
/ * * * huawei mobile phone whether there is a bang reference https://blog.csdn.net/li15225271052/article/details/79967647 * * * /
private static boolean isWindowHasFringeHuawei(Context context) {
try {
ClassLoader classLoader = context.getClassLoader();
Class cls = classLoader.loadClass("com.huawei.android.util.HwNotchSizeUtil");
Method method = cls.getMethod("hasNotchInScreen");
return (boolean) method.invoke(cls);
} catch (Exception e) {
// no-op
}
return false; }}Copy the code