请问android如何判断手机为魅族手机？

Posted

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了请问android如何判断手机为魅族手机？相关的知识，希望对你有一定的参考价值。

需要做魅族手机的适配

如果只是要简单的判断是否为魅族手机的话, 完全可以调用google提供的api来做.
android.os.Build.BRAND
使用上面的属性如果是魅族手机的话返回返回Meizu. 参考技术A

您好，

懂魅族的一眼就能看出来。你可以用手机sn号去魅族官网。服务支持查询真伪服务支持

 参考技术B 查询系统版本号，追问

那魅族手机的版本号是什么呢？

追答

每个手机都不一样，不过版本号的开头是一样的，通过开头就可以判断是魅族手机了

 参考技术C 魅族是flymeOS系统，可以在魅族官网查询SN号追问

系统也有sn号？系统的sn号怎么判断，android手机上?

追答

系统有系统版本号

 参考技术D 设置--关于手机

判断小米 魅族 华为 系统 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

以上是关于请问android如何判断手机为魅族手机？的主要内容，如果未能解决你的问题，请参考以下文章

魅族确认在研Android Go系统手机：年末推出

魅族联合谷歌将推出Android Go手机

android 连不上不上真机魅族

魅族官方确认：将推出首款谷歌Android Go手机

Android之如何分析手机系统相册图片和视频删除后保存的位置然后恢复文件，目前已经适配小米OPPOVIVO一加努比亚魅族等手机。

魅族推出两款Android Go系统手机，魅族16依旧追求手感