码迷，mamicode.com
首页 > 移动开发 > 详细

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

时间：2018-04-20 22:10:51      阅读：575      评论：0      收藏：0      [点我收藏+]

标签：xtu   hid   size   case   sources   ase   over   numbers   else   

获取系统信息

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

标签：xtu   hid   size   case   sources   ase   over   numbers   else   

原文地址：https://www.cnblogs.com/baiqiantao/p/b97c04c79912e606c917429fdf6533fb.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！