判断小米 魅族 华为 系统 MIUI EMUI FLYME

Posted 白乾涛

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了判断小米 魅族 华为 系统 MIUI EMUI FLYME相关的知识，希望对你有一定的参考价值。

获取系统信息

public class SimpleDeviceUtils {
	
	public enum SystemType {
		/**
		 * 小米手机（MIUI系统）
		 */
		SYS_MIUI,
		/**
		 * 华为手机（EMUI系统）
		 */
		SYS_EMUI,
		/**
		 * 魅族手机，FLYME系统
		 */
		SYS_FLYME,
		/**
		 * 其他系统
		 */
		SYS_OTHER
	}
	
	private static final String KEY_MIUI_VERSION_NAME = "ro.miui.ui.version.name";
	private static final String KEY_MIUI_VERSION_CODE = "ro.miui.ui.version.code";
	private static final String KEY_MIUI_INTERNAL_STORAGE = "ro.miui.internal.storage";
	
	private static final String KEY_EMUI_API_LEVEL = "ro.build.hw_emui_api_level";
	private static final String KEY_EMUI_VERSION = "ro.build.version.emui";
	private static final String KEY_EMUI_CONFIG_HW_SYS_VERSION = "ro.confg.hw_systemversion";
	
	/**
	 * 8.0之后有些系统信息获取不到，没有在各种版本手机上逐一测试
	 */
	public static SystemType getSystemType() {
		try {
			Properties prop = new Properties();
			prop.load(new FileInputStream(new File(Environment.getRootDirectory(), "build.prop")));
			if (Build.MANUFACTURER.toLowerCase().equals("xiaomi")//官方提供的判断是否为小米手机（而非MIUI系统）的方法
					|| prop.getProperty(KEY_MIUI_VERSION_NAME, null) != null//QMUI提供的判断是否是MIUI的方法
					|| prop.getProperty(KEY_MIUI_VERSION_CODE, null) != null//下面两个是网上补充的方法，感觉没必要的
					|| prop.getProperty(KEY_MIUI_INTERNAL_STORAGE, null) != null) {
				return SystemType.SYS_MIUI;
			} else if (isEMUI()//华为
					|| prop.getProperty(KEY_EMUI_API_LEVEL, null) != null
					|| prop.getProperty(KEY_EMUI_VERSION, null) != null
					|| prop.getProperty(KEY_EMUI_CONFIG_HW_SYS_VERSION, null) != null) {
				return SystemType.SYS_EMUI;
			} else if (isMeizu()//魅族推送SDK中提供的判断是否是魅族的方法
					|| DeviceHelper.isMeizu()) {//QMUI提供的判断是否是魅族的方法
				return SystemType.SYS_FLYME;
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
		return SystemType.SYS_OTHER;
	}
	
	@SuppressLint("PrivateApi")
	private static boolean isEMUI() {
		Class<?>[] clsArray = new Class<?>[]{String.class};
		Object[] objArray = new Object[]{"ro.build.version.emui"};
		try {
			Class<?> SystemPropertiesClass = Class.forName("android.os.SystemProperties");
			Method get = SystemPropertiesClass.getDeclaredMethod("get", clsArray);
			String version = (String) get.invoke(SystemPropertiesClass, objArray);
			Log.i("bqt", "EMUI version is:" + version);
			return !TextUtils.isEmpty(version);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return false;
	}
	
	/**
	 * 判断是否为魅族设备
	 */
	private static boolean isMeizu() {
		String model = SystemProperties.get("ro.meizu.product.model");
		return (!TextUtils.isEmpty(model)) || "meizu".equalsIgnoreCase(Build.BRAND) || "22c4185e".equalsIgnoreCase(Build.BRAND);
	}
}
1
80
1
public class SimpleDeviceUtils {
2
3
    public enum SystemType {
4
        /**
5
         * 小米手机（MIUI系统）
6
         */
7
        SYS_MIUI,
8
        /**
9
         * 华为手机（EMUI系统）
10
         */
11
        SYS_EMUI,
12
        /**
13
         * 魅族手机，FLYME系统
14
         */
15
        SYS_FLYME,
16
        /**
17
         * 其他系统
18
         */
19
        SYS_OTHER
20
    }
21
22
    private static final String KEY_MIUI_VERSION_NAME = "ro.miui.ui.version.name";
23
    private static final String KEY_MIUI_VERSION_CODE = "ro.miui.ui.version.code";
24
    private static final String KEY_MIUI_INTERNAL_STORAGE = "ro.miui.internal.storage";
25
26
    private static final String KEY_EMUI_API_LEVEL = "ro.build.hw_emui_api_level";
27
    private static final String KEY_EMUI_VERSION = "ro.build.version.emui";
28
    private static final String KEY_EMUI_CONFIG_HW_SYS_VERSION = "ro.confg.hw_systemversion";
29
30
    /**
31
     * 8.0之后有些系统信息获取不到，没有在各种版本手机上逐一测试
32
     */
33
    public static SystemType getSystemType() {
34
        try {
35
            Properties prop = new Properties();
36
            prop.load(new FileInputStream(new File(Environment.getRootDirectory(), "build.prop")));
37
            if (Build.MANUFACTURER.toLowerCase().equals("xiaomi")//官方提供的判断是否为小米手机（而非MIUI系统）的方法
38
                    || prop.getProperty(KEY_MIUI_VERSION_NAME, null) != null//QMUI提供的判断是否是MIUI的方法
39
                    || prop.getProperty(KEY_MIUI_VERSION_CODE, null) != null//下面两个是网上补充的方法，感觉没必要的
40
                    || prop.getProperty(KEY_MIUI_INTERNAL_STORAGE, null) != null) {
41
                return SystemType.SYS_MIUI;
42
            } else if (isEMUI()//华为
43
                    || prop.getProperty(KEY_EMUI_API_LEVEL, null) != null
44
                    || prop.getProperty(KEY_EMUI_VERSION, null) != null
45
                    || prop.getProperty(KEY_EMUI_CONFIG_HW_SYS_VERSION, null) != null) {
46
                return SystemType.SYS_EMUI;
47
            } else if (isMeizu()//魅族推送SDK中提供的判断是否是魅族的方法
48
                    || DeviceHelper.isMeizu()) {//QMUI提供的判断是否是魅族的方法
49
                return SystemType.SYS_FLYME;
50
            }
51
        } catch (IOException e) {
52
            e.printStackTrace();
53
        }
54
        return SystemType.SYS_OTHER;
55
    }
56
57
    @SuppressLint("PrivateApi")
58
    private static boolean isEMUI() {
59
        Class<?>[] clsArray = new Class<?>[]{String.class};
60
        Object[] objArray = new Object[]{"ro.build.version.emui"};
61
        try {
62
            Class<?> SystemPropertiesClass = Class.forName("android.os.SystemProperties");
63
            Method get = SystemPropertiesClass.getDeclaredMethod("get", clsArray);
64
            String version = (String) get.invoke(SystemPropertiesClass, objArray);
65
            Log.i("bqt", "EMUI version is:" + version);
66
            return !TextUtils.isEmpty(version);
67
        } catch (Exception e) {
68
            e.printStackTrace();
69
        }
70
        return false;
71
    }
72
73
    /**
74
     * 判断是否为魅族设备
75
     */
76
    private static boolean isMeizu() {
77
        String model = SystemProperties.get("ro.meizu.product.model");
78
        return (!TextUtils.isEmpty(model)) || "meizu".equalsIgnoreCase(Build.BRAND) || "22c4185e".equalsIgnoreCase(Build.BRAND);
79
    }
80
}

QMUI库中提供的方法

//判断系统厂商，里面的内容基本都来自QMUI库
public class DeviceHelper {
	private final static String KEY_MIUI_VERSION_NAME = "ro.miui.ui.version.name";
	private static final String KEY_FLYME_VERSION_NAME = "ro.build.display.id";
	private final static String FLYME = "flyme";
	private final static String MEIZUBOARD[] = {"m9", "M9", "mx", "MX"};
	private static String sMiuiVersionName;
	private static String sFlymeVersionName;
	
	static {
		Properties properties = new Properties();
		
		if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {// android 8.0，读取 /system/build.prop 会报 permission denied
			FileInputStream fileInputStream = null;
			try {
				fileInputStream = new FileInputStream(new File(Environment.getRootDirectory(), "build.prop"));
				properties.load(fileInputStream);
			} catch (Exception e) {
				e.printStackTrace();
			} finally {
				if (fileInputStream != null) {
					try {
						fileInputStream.close();
					} catch (IOException e) {
						e.printStackTrace();
					}
				}
			}
		}
		
		try {
			Class<?> clzSystemProperties = Class.forName("android.os.SystemProperties");
			Method getMethod = clzSystemProperties.getDeclaredMethod("get", String.class);
			sMiuiVersionName = getLowerCaseName(properties, getMethod, KEY_MIUI_VERSION_NAME);
			sFlymeVersionName = getLowerCaseName(properties, getMethod, KEY_FLYME_VERSION_NAME);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	private static String getLowerCaseName(Properties p, Method get, String key) {
		String name = p.getProperty(key);
		if (name == null) {
			try {
				name = (String) get.invoke(null, key);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		if (name != null) name = name.toLowerCase();
		return name;
	}
	
	private static boolean sIsTabletChecked = false;
	private static boolean sIsTabletValue = false;
	
	/**
	 * 判断是否为平板设备
	 */
	public static boolean isTablet(Context context) {
		if (sIsTabletChecked) {
			return sIsTabletValue;
		} else {
			sIsTabletChecked = true;
			sIsTabletValue = (context.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) >=
					Configuration.SCREENLAYOUT_SIZE_LARGE;
			return sIsTabletValue;
		}
	}
	
	/**
	 * 判断是否是flyme系统
	 */
	public static boolean isFlyme() {
		return !TextUtils.isEmpty(sFlymeVersionName) && sFlymeVersionName.contains(FLYME);
	}
	
	/**
	 * 判断是否是MIUI系统
	 */
	public static boolean isMIUI() {
		return !TextUtils.isEmpty(sMiuiVersionName);
	}
	
	public static boolean isMIUIV5() {
		return "v5".equals(sMiuiVersionName);
	}
	
	public static boolean isMIUIV6() {
		return "v6".equals(sMiuiVersionName);
	}
	
	public static boolean isMIUIV7() {
		return "v7".equals(sMiuiVersionName);
	}
	
	public static boolean isMIUIV8() {
		return "v8".equals(sMiuiVersionName);
	}
	
	public static boolean isMIUIV9() {
		return "v9".equals(sMiuiVersionName);
	}
	
	public static boolean isFlymeVersionHigher5_2_4() {
		//查不到默认高于5.2.4
		boolean isHigher = true;
		if (sFlymeVersionName != null && !sFlymeVersionName.equals("")) {
			Pattern pattern = Pattern.compile("(\\d+\\.){2}\\d");
			Matcher matcher = pattern.matcher(sFlymeVersionName);
			if (matcher.find()) {
				String versionString = matcher.group();
				if (versionString != null && !versionString.equals("")) {
					String[] version = versionString.split("\\.");
					if (version.length == 3) {
						if (Integer.valueOf(version[0]) < 5) {
							isHigher = false;
						} else if (Integer.valueOf(version[0]) > 5) {
							isHigher = true;
						} else {
							if (Integer.valueOf(version[1]) < 2) {
								isHigher = false;
							} else if (Integer.valueOf(version[1]) > 2) {
								isHigher = true;
							} else {
								if (Integer.valueOf(version[2]) < 4) {
									isHigher = false;
								} else if (Integer.valueOf(version[2]) >= 5) {
									isHigher = true;
								}
							}
						}
					}
					
				}
			}
		}
		return isMeizu() && isHigher;
	}
	
	/**
	 * 判断是否为魅族
	 */
	public static boolean isMeizu() {
		return isSpecialBoardPhone(MEIZUBOARD) || isFlyme();
	}
	
	/**
	 * 判断是否为小米，详见https://dev.mi.com/doc/?p=254
	 */
	public static boolean isXiaomi() {
		return Build.MANUFACTURER.toLowerCase().equals("xiaomi");
	}
	
	/**
	 * 是否是指定型号的手机
	 */
	private static boolean isSpecialBoardPhone(String[] boards) {
		String board = android.os.Build.BOARD;
		if (board != null) {
			for (String b : boards) {
				if (board.equals(b)) {
					return true;
				}
			}
		}
		return false;
	}
}
169
 
1
//判断系统厂商，里面的内容基本都来自QMUI库
2
public class DeviceHelper {
3
    private final static String KEY_MIUI_VERSION_NAME = "ro.miui.ui.version.name";
4
    private static final String KEY_FLYME_VERSION_NAME = "ro.build.display.id";
5
    private final static String FLYME = "flyme";
6
    private final static String MEIZUBOARD[] = {"m9", "M9", "mx", "MX"};
7
    private static String sMiuiVersionName;
8
    private static String sFlymeVersionName;
9
10
    static {
11
        Properties properties = new Properties();
12
13
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {// android 8.0，读取 /system/build.prop 会报 permission denied
14
            FileInputStream fileInputStream = null;
15
            try {
16
                fileInputStream = new FileInputStream(new File(Environment.getRootDirectory(), "build.prop"));
17
                properties.load(fileInputStream);
18
            } catch (Exception e) {
19
                e.printStackTrace();
20
            } finally {
21
                if (fileInputStream != null) {
22
                    try {
23
                        fileInputStream.close();
24
                    } catch (IOException e) {
25
                        e.printStackTrace();
26
                    }
27
                }
28
            }
29
        }
30
31
        try {
32
            Class<?> clzSystemProperties = Class.forName("android.os.SystemProperties");
33
            Method getMethod = clzSystemProperties.getDeclaredMethod("get", String.class);
34
            sMiuiVersionName = getLowerCaseName(properties, getMethod, KEY_MIUI_VERSION_NAME);
35
            sFlymeVersionName = getLowerCaseName(properties, getMethod, KEY_FLYME_VERSION_NAME);
36
        } catch (Exception e) {
37
            e.printStackTrace();
38
        }
39
    }
40
41
    private static String getLowerCaseName(Properties p, Method get, String key) {
42
        String name = p.getProperty(key);
43
        if (name == null) {
44
            try {
45
                name = (String) get.invoke(null, key);
46
            } catch (Exception e) {
47
                e.printStackTrace();
48
            }
49
        }
50
        if (name != null) name = name.toLowerCase();
51
        return name;
52
    }
53
54
    private static boolean sIsTabletChecked = false;
55
    private static boolean sIsTabletValue = false;
56
57
    /**
58
     * 判断是否为平板设备
59
     */
60
    public static boolean isTablet(Context context) {
61
        if (sIsTabletChecked) {
62
            return sIsTabletValue;
63
        } else {
64
            sIsTabletChecked = true;
65
            sIsTabletValue = (context.getResources().getConfiguration().screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK) >=
66
                    Configuration.SCREENLAYOUT_SIZE_LARGE;
67
            return sIsTabletValue;
68
        }
69
    }
70
71
    /**
72
     * 判断是否是flyme系统
73
     */
74
    public static boolean isFlyme() {
75
        return !TextUtils.isEmpty(sFlymeVersionName) && sFlymeVersionName.contains(FLYME);
76
    }
77
78
    /**
79
     * 判断是否是MIUI系统
80
     */
81
    public static boolean isMIUI() {
82
        return !TextUtils.isEmpty(sMiuiVersionName);
83
    }
84
85
    public static boolean isMIUIV5() {
86
        return "v5".equals(sMiuiVersionName);
87
    }
88
89
    public static boolean isMIUIV6() {
90
        return "v6".equals(sMiuiVersionName);
91
    }
92
93
    public static boolean isMIUIV7() {
94
        return "v7".equals(sMiuiVersionName);
95
    }
96
97
    public static boolean isMIUIV8() {
98
        return "v8".equals(sMiuiVersionName);
99
    }
100
101
    public static boolean isMIUIV9() {
102
        return "v9".equals(sMiuiVersionName);
103
    }
104
105
    public static boolean isFlymeVersionHigher5_2_4() {
106
        //查不到默认高于5.2.4
107
        boolean isHigher = true;
108
        if (sFlymeVersionName != null && !sFlymeVersionName.equals("")) {
109
            Pattern pattern = Pattern.compile("(\\d+\\.){2}\\d");
110
            Matcher matcher = pattern.matcher(sFlymeVersionName);
111
            if (matcher.find()) {
112
                String versionString = matcher.group();
113
                if (versionString != null && !versionString.equals("")) {
114
                    String[] version = versionString.split("\\.");
115
                    if (version.length == 3) {
116
                        if (Integer.valueOf(version[0]) < 5) {
117
                            isHigher = false;
118
                        } else if (Integer.valueOf(version[0]) > 5) {
119
                            isHigher = true;
120
                        } else {
121
                            if (Integer.valueOf(version[1]) < 2) {
122
                                isHigher = false;
123
                            } else if (Integer.valueOf(version[1]) > 2) {
124
                                isHigher = true;
125
                            } else {
126
                                if (Integer.valueOf(version[2]) < 4) {
127
                                    isHigher = false;
128
                                } else if (Integer.valueOf(version[2]) >= 5) {
129
                                    isHigher = true;
130
                                }
131
                            }
132
                        }
133
                    }
134
135
                }
136
            }
137
        }
138
        return isMeizu() && isHigher;
139
    }
140
141
    /**
142
     * 判断是否为魅族
143
     */
144
    public static boolean isMeizu() {
145
        return isSpecialBoardPhone(MEIZUBOARD) || isFlyme();
146
    }
147
148
    /**
149
     * 判断是否为小米，详见https://dev.mi.com/doc/?p=254
150
     */
151
    public static boolean isXiaomi() {
152
        return Build.MANUFACTURER.toLowerCase().equals("xiaomi");
153
    }
154
155
    /**
156
     * 是否是指定型号的手机
157
     */
158
    private static boolean isSpecialBoardPhone(String[] boards) {
159
        String board = android.os.Build.BOARD;
160
        if (board != null) {
161
            for (String b : boards) {
162
                if (board.equals(b)) {
163
                    return true;
164
                }
165
            }
166
        }
167
        return false;
168
    }
169
}
2018-4-20

以上是关于判断小米 魅族 华为 系统 MIUI EMUI FLYME的主要内容，如果未能解决你的问题，请参考以下文章

港媒：华为正在开发自己的操作系统

国内手机操作系统哪个好？看完你就明白了

打擂台了，华为鸿蒙是分布式系统，小米MIUI13有分布式菜单

Android面试题-机型适配之痛，例如三星小米华为魅族等。

「阉割版」小米和魅族正式亮相美国

省电模式怎么关闭