安全风险 - 检测设备是否为模仿器

在很多安全机构的检测中，关于模仿器的运行环境一般也会做监听处理，有的大概答应实行但是会提示用户，有的大概直接克制在模仿器上运行我方APP
  怎样判定当前 app 是运行在Android真机，还是运行在模仿器? 大概做 Framework 的朋友头脑会更开阔一些，不过现在也可以跟我这门外汉一起来轻微相识下

  
攻略过程

   其实我已经很久没有效过模仿器了，不过可以肯定的是模仿器与真机的本质区别大概率在于运行载体
  Android 有非常多的模仿器，我已知的有官方自带的 Genymotion 模仿器，三方平台的夜神模仿器、天天模仿器等，以是想要完全鉴别出设备的运行环境，其实应该是存在肯定题目的，我们只能说尽大概保证肯定的容错率（我有想过很多应用平台提供的云机，但好像大多提供的都是真机，以是此项不在思量范围之内）
基础思考

以下的一些思考紧张结合了 怎样判定是否是模仿器还是真机、全面检测设备是否模仿器、一行代码帮你检测Android模仿器、安卓逆向环境检测–模仿器 等多篇新旧文章

• IMEI 设备辨认码：用于唯一标识移动设备（放弃）
  

模仿器的 IMEI 可以修改，早期平板大概没有IMEI，但是随着时代发展很多平板设备已拥有了属于本身的IMEI

• MAC地址：物理地址，硬件地址，也称局域网地址，由网络设备制造商生产时烧录在网卡（放弃）
  

模仿器的MAC地址是固定的几种，但是这些固定的地址随着模仿器类型递增，没有找到合适的，同时mac地址现在可以被模仿…

• 通过调用公开或者隐藏的体系API判定（放弃）
  

因为调用结果可以容易被修改，好比直接修改Android的源代码或者借助 Xposed Framework 举行修改（这种场景我虽未到场，但是应该可以参考Java的反射机制）

• 功能验证：初期模仿器功能并不完善，可以采用类似 打电话、发短信 等方式举行功能测试，但是后续随着模仿器升级已补全对应功能 (放弃)
  

1. public boolean isSimulator1() {
2.         String url = "tel:" + "10086";
3.         Intent intent = new Intent();
4.         intent.setData(Uri.parse(url));
5.         intent.setAction(Intent.ACTION_DIAL);
6.         // 是否可以处理跳转到拨号的 Intent
7.         boolean canResolveIntent = intent.resolveActivity(mContext.getPackageManager()) != null;
8.                 return !canResolveIntent;
9. }

复制代码

• 设备IDS、特有文件验证（放弃）
  

涉及到敏感权限时需要申请权限，根据授权结果容易出现误判，同时影响用户体验

1.     private static String[]known_numbers = {"15555215554","15555215556",
2.             "15555215558","15555215560","15555215562","15555215564",
3.             "15555215566","15555215568","15555215570","15555215572",
4.             "15555215574","15555215576","15555215578","15555215580",
5.             "15555215582","15555215584",};
6.     public static Boolean CheckPhoneNumber(Context context){
7.         TelephonyManager telephonyManager =(TelephonyManager)context
8.                 .getSystemService(Context.TELEPHONY_SERVICE);
9.         String phonenumber =telephonyManager.getLine1Number();
10.         for(String number :known_numbers){
11.             if(number.equalsIgnoreCase(phonenumber)){
12.                 Log.v("Result:","Find PhoneNumber!");
13.                 return true;
14.             }
15.         }
16.         Log.v("Result:","Not Find PhoneNumber!");
17.         return false;
18.     }

复制代码

特有文件检测 - 权限要求

设备IDS检测 - 权限要求

• CPU检测方法：现在的模仿器基本可以做到模仿手机号码，手机品牌，cpu信息等，好比清闲/夜神模仿器读取 ro.product.board 举行了处理，能得到预先设置的cpu信息（放弃）
  

1. public static boolean checkIsNotRealPhone() {
2.     String cpuInfo = readCpuInfo();
3.     if ((cpuInfo.contains("intel") || cpuInfo.contains("amd"))) {
4.         return true;
5.     }
6.     return false;
7. }
8. public static String readCpuInfo() {
9.     String result = "";
10.     try {
11.         String[] args = {"/system/bin/cat", "/proc/cpuinfo"};
12.         ProcessBuilder cmd = new ProcessBuilder(args);
13.         Process process = cmd.start();
14.         StringBuffer sb = new StringBuffer();
15.         String readLine = "";
16.         BufferedReader responseReader = new BufferedReader(new InputStreamReader(process.getInputStream(), "utf-8"));
17.         while ((readLine = responseReader.readLine()) != null) {
18.             sb.append(readLine);
19.         }
20.         responseReader.close();
21.         result = sb.toString().toLowerCase();
22.     } catch (IOException ex) {
23.     }
24.     return result;
25. }

复制代码

进阶思考

在一篇Blog内有看到这样一副图，值得借鉴，因为我末了使用的 easyprotector 框架就做了硬件信息检测

Tip：有爱好的可以参考以下方法扩展 easyprotector 框架内的模仿器检测部分
模仿器框架文件

2. UNEXPORT void AntiEmulator::check_file() {
3.     char *(path[]) = {
4.             "/system/bin/androVM-prop",   //检测androidVM
5.             "/system/bin/microvirt-prop", //检测逍遥模拟器--新版本找不到特征
6.             "/system/lib/libdroid4x.so",  //检测海马模拟器
7.             "/system/bin/windroyed",      //检测文卓爷模拟器
8.             "/system/bin/nox-prop",       //检测夜神模拟器--某些版本找不到特征
9.             "/system/lib/libnoxspeedup.so",//检测夜神模拟器
10.             "/system/bin/ttVM-prop",      //检测天天模拟器
11.             "/data/.bluestacks.prop",     //检测bluestacks模拟器  51模拟器
12.             "/system/bin/duosconfig",     //检测AMIDuOS模拟器
13.             "/system/etc/xxzs_prop.sh",   //检测星星模拟器
14.             "/system/etc/mumu-configs/device-prop-configs/mumu.config", //网易MuMu模拟器
15.             "/system/priv-app/ldAppStore",   //雷电模拟器
16.             "/system/bin/ldinit",             //雷电模拟器
17.             "/system/bin/ldmountsf",          //雷电模拟器
18.             "/system/app/AntStore",          //小蚁模拟器
19.             "/system/app/AntLauncher",       //小蚁模拟器
20.             "vmos.prop",                     //vmos虚拟机
21.             "fstab.titan",                   //光速虚拟机
22.             "init.titan.rc",                 //光速虚拟机
23.             "x8.prop",                       //x8沙箱和51虚拟机
24.             "/system/lib/libc_malloc_debug_qemu.so", //AVD QEMU
25.             "/system/bin/microvirtd",
26.             "/dev/socket/qemud",
27.             "/dev/qemu_pipe"};
28.     for (int i = 0; i < sizeof(path) / sizeof(char*); i++){
29.         if (Syscall::check_file_or_dir_exists(path[i])){
30.             LOGI("check_file  %s file existing", path[i]);
31.             // TODO 风险
33.         }
34.     }
35. }

复制代码

---

easyprotector 框架剖析

   关于 easyprotector框架 文档可以参考 一行代码帮你检测Android模仿器（更新至1.1.0） 会更详细一些
  我之以是在 github 选这个框架，紧张有几点原因

• 模仿器检测框架有限
  
• 该框架star高
  
• 检测方面思量全面（检测渠道、设备型号、硬件制造商、主板名称、基带信息、第三方应用数量、传感器数量、是否支持蓝牙、是否支持相机、是否支持闪光灯等）
  
• 本领之内可以适当扩展检测项
  
• 为了避免误判设备类型，内部参加条件判定，只有满意3项模仿器特性才会判定为模仿器
  

直接通过框架源码，检察下模仿器检测的实行过程

• 调用了 EasyProtectorLib.checkIsRunningInEmulator 方法
  

• 在 EasyProtectorLib 中找到了 checkIsRunningInEmulator 实际调用了 EmulatorCheckUtil
  

• 检察 EmulatorCheckUtil - readSysProperty 源码即可
  

   源码中 ro.build、ro.product、gsm.version 含义，做Framework朋友大概比力相识，紧张用于检测一些体系级信息
  

之前有提到功能扩展和延伸，各人可自行在该类源码中举行扩展，不过最好另起方法，有自信的话改原方法也行

---

剥离 easyprotector框架 模仿器检测功能

因为 easyprotector框架 中涉及的功能比力多，我习惯性只抽出了我所需要的部分
CommandUtil （公共、基础）

简单来看紧张是通过反射机制获取一些体系的公共资源信息

1. import java.io.BufferedInputStream;
2. import java.io.BufferedOutputStream;
3. import java.io.IOException;
5. /**
6. * Project Name:EasyProtector
7. * Package Name:com.lahm.library
8. * Created by lahm on 2018/6/8 16:23 .
9. */
10. public class CommandUtil {
11.     private CommandUtil() {
12.     }
14.     private static class SingletonHolder {
15.         private static final CommandUtil INSTANCE = new CommandUtil();
16.     }
18.     public static final CommandUtil getSingleInstance() {
19.         return SingletonHolder.INSTANCE;
20.     }
22.     public String getProperty(String propName) {
23.         String value = null;
24.         Object roSecureObj;
25.         try {
26.             roSecureObj = Class.forName("android.os.SystemProperties")
27.                     .getMethod("get", String.class)
28.                     .invoke(null, propName);
29.             if (roSecureObj != null) value = (String) roSecureObj;
30.         } catch (Exception e) {
31.             value = null;
32.         } finally {
33.             return value;
34.         }
35.     }
37.     public String exec(String command) {
38.         BufferedOutputStream bufferedOutputStream = null;
39.         BufferedInputStream bufferedInputStream = null;
40.         Process process = null;
41.         try {
42.             process = Runtime.getRuntime().exec("sh");
43.             bufferedOutputStream = new BufferedOutputStream(process.getOutputStream());
45.             bufferedInputStream = new BufferedInputStream(process.getInputStream());
46.             bufferedOutputStream.write(command.getBytes());
47.             bufferedOutputStream.write('\n');
48.             bufferedOutputStream.flush();
49.             bufferedOutputStream.close();
51.             process.waitFor();
53.             String outputStr = getStrFromBufferInputSteam(bufferedInputStream);
54.             return outputStr;
55.         } catch (Exception e) {
56.             return null;
57.         } finally {
58.             if (bufferedOutputStream != null) {
59.                 try {
60.                     bufferedOutputStream.close();
61.                 } catch (IOException e) {
62.                     e.printStackTrace();
63.                 }
64.             }
65.             if (bufferedInputStream != null) {
66.                 try {
67.                     bufferedInputStream.close();
68.                 } catch (IOException e) {
69.                     e.printStackTrace();
70.                 }
71.             }
72.             if (process != null) {
73.                 process.destroy();
74.             }
75.         }
76.     }
78.     private static String getStrFromBufferInputSteam(BufferedInputStream bufferedInputStream) {
79.         if (null == bufferedInputStream) {
80.             return "";
81.         }
82.         int BUFFER_SIZE = 512;
83.         byte[] buffer = new byte[BUFFER_SIZE];
84.         StringBuilder result = new StringBuilder();
85.         try {
86.             while (true) {
87.                 int read = bufferedInputStream.read(buffer);
88.                 if (read > 0) {
89.                     result.append(new String(buffer, 0, read));
90.                 }
91.                 if (read < BUFFER_SIZE) {
92.                     break;
93.                 }
94.             }
95.         } catch (Exception e) {
96.             e.printStackTrace();
97.         }
98.         return result.toString();
99.     }
100. }

复制代码

EmulatorCheckUtil （核心）

1. import android.content.Context;
2. import android.content.pm.PackageManager;
3. import android.hardware.Sensor;
4. import android.hardware.SensorManager;
5. import android.text.TextUtils;
7. import static android.content.Context.SENSOR_SERVICE;
8. import static cn.com.huaan.fund.acts.base.safe.CheckResult.RESULT_EMULATOR;
9. import static cn.com.huaan.fund.acts.base.safe.CheckResult.RESULT_MAYBE_EMULATOR;
10. import static cn.com.huaan.fund.acts.base.safe.CheckResult.RESULT_UNKNOWN;
13. /**
14. * Project Name:EasyProtector
15. * Package Name:com.lahm.library
16. * Created by lahm on 2018/6/8 15:01 .
17. */
18. public class EmulatorCheckUtil {
19.     private EmulatorCheckUtil() {
21.     }
23.     private static class SingletonHolder {
24.         private static final EmulatorCheckUtil INSTANCE = new EmulatorCheckUtil();
25.     }
27.     public static final EmulatorCheckUtil getSingleInstance() {
28.         return SingletonHolder.INSTANCE;
29.     }
31.     public boolean readSysProperty(Context context, EmulatorCheckCallback callback) {
32.         if (context == null)
33.             throw new IllegalArgumentException("context must not be null");
35.         int suspectCount = 0;
37.         //检测硬件名称
38.         CheckResult hardwareResult = checkFeaturesByHardware();
39.         switch (hardwareResult.result) {
40.             case RESULT_MAYBE_EMULATOR:
41.                 ++suspectCount;
42.                 break;
43.             case RESULT_EMULATOR:
44.                 if (callback != null) callback.findEmulator("hardware = " + hardwareResult.value);
45.                 return true;
46.         }
48.         //检测渠道
49.         CheckResult flavorResult = checkFeaturesByFlavor();
50.         switch (flavorResult.result) {
51.             case RESULT_MAYBE_EMULATOR:
52.                 ++suspectCount;
53.                 break;
54.             case RESULT_EMULATOR:
55.                 if (callback != null) callback.findEmulator("flavor = " + flavorResult.value);
56.                 return true;
57.         }
59.         //检测设备型号
60.         CheckResult modelResult = checkFeaturesByModel();
61.         switch (modelResult.result) {
62.             case RESULT_MAYBE_EMULATOR:
63.                 ++suspectCount;
64.                 break;
65.             case RESULT_EMULATOR:
66.                 if (callback != null) callback.findEmulator("model = " + modelResult.value);
67.                 return true;
68.         }
70.         //检测硬件制造商
71.         CheckResult manufacturerResult = checkFeaturesByManufacturer();
72.         switch (manufacturerResult.result) {
73.             case RESULT_MAYBE_EMULATOR:
74.                 ++suspectCount;
75.                 break;
76.             case RESULT_EMULATOR:
77.                 if (callback != null)
78.                     callback.findEmulator("manufacturer = " + manufacturerResult.value);
79.                 return true;
80.         }
82.         //检测主板名称
83.         CheckResult boardResult = checkFeaturesByBoard();
84.         switch (boardResult.result) {
85.             case RESULT_MAYBE_EMULATOR:
86.                 ++suspectCount;
87.                 break;
88.             case RESULT_EMULATOR:
89.                 if (callback != null) callback.findEmulator("board = " + boardResult.value);
90.                 return true;
91.         }
93.         //检测主板平台
94.         CheckResult platformResult = checkFeaturesByPlatform();
95.         switch (platformResult.result) {
96.             case RESULT_MAYBE_EMULATOR:
97.                 ++suspectCount;
98.                 break;
99.             case RESULT_EMULATOR:
100.                 if (callback != null) callback.findEmulator("platform = " + platformResult.value);
101.                 return true;
102.         }
104.         //检测基带信息
105.         CheckResult baseBandResult = checkFeaturesByBaseBand();
106.         switch (baseBandResult.result) {
107.             case RESULT_MAYBE_EMULATOR:
108.                 suspectCount += 2;//模拟器基带信息为null的情况概率相当大
109.                 break;
110.             case RESULT_EMULATOR:
111.                 if (callback != null) callback.findEmulator("baseBand = " + baseBandResult.value);
112.                 return true;
113.         }
115.         //检测传感器数量
116.         int sensorNumber = getSensorNumber(context);
117.         if (sensorNumber <= 7) ++suspectCount;
119.         //检测已安装第三方应用数量
120.         int userAppNumber = getUserAppNumber();
121.         if (userAppNumber <= 5) ++suspectCount;
123.         //检测是否支持闪光灯
124.         boolean supportCameraFlash = supportCameraFlash(context);
125.         if (!supportCameraFlash) ++suspectCount;
126.         //检测是否支持相机
127.         boolean supportCamera = supportCamera(context);
128.         if (!supportCamera) ++suspectCount;
129.         //检测是否支持蓝牙
130.         boolean supportBluetooth = supportBluetooth(context);
131.         if (!supportBluetooth) ++suspectCount;
133.         //检测光线传感器
134.         boolean hasLightSensor = hasLightSensor(context);
135.         if (!hasLightSensor) ++suspectCount;
137.         //检测进程组信息
138.         CheckResult cgroupResult = checkFeaturesByCgroup();
139.         if (cgroupResult.result == RESULT_MAYBE_EMULATOR) ++suspectCount;
141.         if (callback != null) {
142.             StringBuffer stringBuffer = new StringBuffer("Test start")
143.                     .append("\r\n").append("hardware = ").append(hardwareResult.value)
144.                     .append("\r\n").append("flavor = ").append(flavorResult.value)
145.                     .append("\r\n").append("model = ").append(modelResult.value)
146.                     .append("\r\n").append("manufacturer = ").append(manufacturerResult.value)
147.                     .append("\r\n").append("board = ").append(boardResult.value)
148.                     .append("\r\n").append("platform = ").append(platformResult.value)
149.                     .append("\r\n").append("baseBand = ").append(baseBandResult.value)
150.                     .append("\r\n").append("sensorNumber = ").append(sensorNumber)
151.                     .append("\r\n").append("userAppNumber = ").append(userAppNumber)
152.                     .append("\r\n").append("supportCamera = ").append(supportCamera)
153.                     .append("\r\n").append("supportCameraFlash = ").append(supportCameraFlash)
154.                     .append("\r\n").append("supportBluetooth = ").append(supportBluetooth)
155.                     .append("\r\n").append("hasLightSensor = ").append(hasLightSensor)
156.                     .append("\r\n").append("cgroupResult = ").append(cgroupResult.value)
157.                     .append("\r\n").append("suspectCount = ").append(suspectCount);
158.             callback.findEmulator(stringBuffer.toString());
159.         }
160.         //嫌疑值大于3，认为是模拟器
161.         return suspectCount > 3;
162.     }
164.     private int getUserAppNum(String userApps) {
165.         if (TextUtils.isEmpty(userApps)) return 0;
166.         String[] result = userApps.split("package:");
167.         return result.length;
168.     }
170.     private String getProperty(String propName) {
171.         String property = CommandUtil.getSingleInstance().getProperty(propName);
172.         return TextUtils.isEmpty(property) ? null : property;
173.     }
175.     /**
176.      * 特征参数-硬件名称
177.      *
178.      * @return 0表示可能是模拟器，1表示模拟器，2表示可能是真机
179.      */
180.     private CheckResult checkFeaturesByHardware() {
181.         String hardware = getProperty("ro.hardware");
182.         if (null == hardware) return new CheckResult(RESULT_MAYBE_EMULATOR, null);
183.         int result;
184.         String tempValue = hardware.toLowerCase();
185.         switch (tempValue) {
186.             case "ttvm"://天天模拟器
187.             case "nox"://夜神模拟器
188.             case "cancro"://网易MUMU模拟器
189.             case "intel"://逍遥模拟器
190.             case "vbox":
191.             case "vbox86"://腾讯手游助手
192.             case "android_x86"://雷电模拟器
193.                 result = RESULT_EMULATOR;
194.                 break;
195.             default:
196.                 result = RESULT_UNKNOWN;
197.                 break;
198.         }
199.         return new CheckResult(result, hardware);
200.     }
202.     /**
203.      * 特征参数-渠道
204.      *
205.      * @return 0表示可能是模拟器，1表示模拟器，2表示可能是真机
206.      */
207.     private CheckResult checkFeaturesByFlavor() {
208.         String flavor = getProperty("ro.build.flavor");
209.         if (null == flavor) return new CheckResult(RESULT_MAYBE_EMULATOR, null);
210.         int result;
211.         String tempValue = flavor.toLowerCase();
212.         if (tempValue.contains("vbox")) result = RESULT_EMULATOR;
213.         else if (tempValue.contains("sdk_gphone")) result = RESULT_EMULATOR;
214.         else result = RESULT_UNKNOWN;
215.         return new CheckResult(result, flavor);
216.     }
218.     /**
219.      * 特征参数-设备型号
220.      *
221.      * @return 0表示可能是模拟器，1表示模拟器，2表示可能是真机
222.      */
223.     private CheckResult checkFeaturesByModel() {
224.         String model = getProperty("ro.product.model");
225.         if (null == model) return new CheckResult(RESULT_MAYBE_EMULATOR, null);
226.         int result;
227.         String tempValue = model.toLowerCase();
228.         if (tempValue.contains("google_sdk")) result = RESULT_EMULATOR;
229.         else if (tempValue.contains("emulator")) result = RESULT_EMULATOR;
230.         else if (tempValue.contains("android sdk built for x86")) result = RESULT_EMULATOR;
231.         else result = RESULT_UNKNOWN;
232.         return new CheckResult(result, model);
233.     }
235.     /**
236.      * 特征参数-硬件制造商
237.      *
238.      * @return 0表示可能是模拟器，1表示模拟器，2表示可能是真机
239.      */
240.     private CheckResult checkFeaturesByManufacturer() {
241.         String manufacturer = getProperty("ro.product.manufacturer");
242.         if (null == manufacturer) return new CheckResult(RESULT_MAYBE_EMULATOR, null);
243.         int result;
244.         String tempValue = manufacturer.toLowerCase();
245.         if (tempValue.contains("genymotion")) result = RESULT_EMULATOR;
246.         else if (tempValue.contains("netease")) result = RESULT_EMULATOR;//网易MUMU模拟器
247.         else result = RESULT_UNKNOWN;
248.         return new CheckResult(result, manufacturer);
249.     }
251.     /**
252.      * 特征参数-主板名称
253.      *
254.      * @return 0表示可能是模拟器，1表示模拟器，2表示可能是真机
255.      */
256.     private CheckResult checkFeaturesByBoard() {
257.         String board = getProperty("ro.product.board");
258.         if (null == board) return new CheckResult(RESULT_MAYBE_EMULATOR, null);
259.         int result;
260.         String tempValue = board.toLowerCase();
261.         if (tempValue.contains("android")) result = RESULT_EMULATOR;
262.         else if (tempValue.contains("goldfish")) result = RESULT_EMULATOR;
263.         else result = RESULT_UNKNOWN;
264.         return new CheckResult(result, board);
265.     }
267.     /**
268.      * 特征参数-主板平台
269.      *
270.      * @return 0表示可能是模拟器，1表示模拟器，2表示可能是真机
271.      */
272.     private CheckResult checkFeaturesByPlatform() {
273.         String platform = getProperty("ro.board.platform");
274.         if (null == platform) return new CheckResult(RESULT_MAYBE_EMULATOR, null);
275.         int result;
276.         String tempValue = platform.toLowerCase();
277.         if (tempValue.contains("android")) result = RESULT_EMULATOR;
278.         else result = RESULT_UNKNOWN;
279.         return new CheckResult(result, platform);
280.     }
282.     /**
283.      * 特征参数-基带信息
284.      *
285.      * @return 0表示可能是模拟器，1表示模拟器，2表示可能是真机
286.      */
287.     private CheckResult checkFeaturesByBaseBand() {
288.         String baseBandVersion = getProperty("gsm.version.baseband");
289.         if (null == baseBandVersion) return new CheckResult(RESULT_MAYBE_EMULATOR, null);
290.         int result;
291.         if (baseBandVersion.contains("1.0.0.0")) result = RESULT_EMULATOR;
292.         else result = RESULT_UNKNOWN;
293.         return new CheckResult(result, baseBandVersion);
294.     }
296.     /**
297.      * 获取传感器数量
298.      */
299.     private int getSensorNumber(Context context) {
300.         SensorManager sm = (SensorManager) context.getSystemService(SENSOR_SERVICE);
301.         return sm.getSensorList(Sensor.TYPE_ALL).size();
302.     }
304.     /**
305.      * 获取已安装第三方应用数量
306.      */
307.     private int getUserAppNumber() {
308.         String userApps = CommandUtil.getSingleInstance().exec("pm list package -3");
309.         return getUserAppNum(userApps);
310.     }
312.     /**
313.      * 是否支持相机
314.      */
315.     private boolean supportCamera(Context context) {
316.         return context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_CAMERA);
317.     }
319.     /**
320.      * 是否支持闪光灯
321.      */
322.     private boolean supportCameraFlash(Context context) {
323.         return context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_CAMERA_FLASH);
324.     }
326.     /**
327.      * 是否支持蓝牙
328.      */
329.     private boolean supportBluetooth(Context context) {
330.         return context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_BLUETOOTH);
331.     }
333.     /**
334.      * 判断是否存在光传感器来判断是否为模拟器
335.      * 部分真机也不存在温度和压力传感器。其余传感器模拟器也存在。
336.      *
337.      * @return false为模拟器
338.      */
339.     private boolean hasLightSensor(Context context) {
340.         SensorManager sensorManager = (SensorManager) context.getSystemService(SENSOR_SERVICE);
341.         Sensor sensor = sensorManager.getDefaultSensor(Sensor.TYPE_LIGHT); //光线传感器
342.         if (null == sensor) return false;
343.         else return true;
344.     }
346.     /**
347.      * 特征参数-进程组信息
348.      */
349.     private CheckResult checkFeaturesByCgroup() {
350.         String filter = CommandUtil.getSingleInstance().exec("cat /proc/self/cgroup");
351.         if (null == filter) return new CheckResult(RESULT_MAYBE_EMULATOR, null);
352.         return new CheckResult(RESULT_UNKNOWN, filter);
353.     }
354. }

复制代码

EmulatorCheckCallback （配置）

回调监听，可以获取到具体检测结果

1. public interface EmulatorCheckCallback {
2.     void findEmulator(String emulatorInfo);
3. }

复制代码

CheckResult（配置）

对检测结果举行种别分别，方便管理

1. public class CheckResult {
2.     public static final int RESULT_MAYBE_EMULATOR = 0;//可能是模拟器
3.     public static final int RESULT_EMULATOR = 1;//模拟器
4.     public static final int RESULT_UNKNOWN = 2;//可能是真机
6.     public int result;
7.     public String value;
9.     public CheckResult(int result, String value) {
10.         this.result = result;
11.         this.value = value;
12.     }
13. }

复制代码

调用方式

1. val readSysProperty = EmulatorCheckUtil.getSingleInstance().readSysProperty(context, null)
2. if (readSysProperty) {
3.      //根据需要进行风险提示等相关业务
4.      ToastUtils.showToast("您当前可能运行在模拟器设备，请谨防安全风险！")
5. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。