• 安卓判断是否是模拟器，适配主流雷电，MUMU，夜神，逍遥

    前言

    最近游戏项目组又有新的要求，对于数据上报和数据统计接口，尽可能的具体化，比如是否是模拟器，模拟器的型号，品牌等，都要求统计，后续模拟器玩家在活动发放，安全风控等方面也易于分析和把控。

    实现

    在网上搜了搜，大概思路是：

    1：模拟器的cpu是x86，arm的，通过cpu信息判断

    2：模拟器的传感器比较少，尤其没有光传感器等

    3：模拟器没有蓝牙模块，可以通过蓝牙判断，这里没有考虑，毕竟需要动态权限

    Manifest.permission.BLUETOOTH_CONNECT

    在隐私合规的大环境下，还是尽量避免获取多的权限

    4：通过部分特征参数，比如Build.FINGERPRINT、 Build.MODEL、Build.BRAND

    5：通过模拟器特有文件检测

    下面具体贴上工具类代码：

    1. package com.xx.xx.myapplication;
    2.  
    3. import android.bluetooth.BluetoothAdapter;
    4. import android.content.Context;
    5. import android.content.pm.PackageManager;
    6. import android.hardware.Sensor;
    7. import android.hardware.SensorManager;
    8. import android.os.Build;
    9. import android.text.TextUtils;
    10. import android.util.Log;
    11.  
    12. import java.io.BufferedReader;
    13. import java.io.File;
    14. import java.io.IOException;
    15. import java.io.InputStreamReader;
    16. import java.util.ArrayList;
    17. import java.util.List;
    18.  
    19. public class EmutorUtils {
    20.  
    21.     private static final String TAG = "EmutorUtils";
    22.  
    23.     private static final String[] PKG_NAMES = {"com.mumu.launcher", "com.ami.duosupdater.ui", "com.ami.launchmetro",
    24.             "com.ami.syncduosservices", "com.bluestacks.home", "com.bluestacks.windowsfilemanager",
    25.             "com.bluestacks.settings", "com.bluestacks.bluestackslocationprovider", "com.bluestacks.appsettings",
    26.             "com.bluestacks.bstfolder", "com.bluestacks.BstCommandProcessor", "com.bluestacks.s2p", "com.bluestacks.setup",
    27.             "com.bluestacks.appmart", "com.kaopu001.tiantianserver", "com.kpzs.helpercenter", "com.kaopu001.tiantianime",
    28.             "com.android.development_settings", "com.android.development", "com.android.customlocale2", "com.genymotion.superuser",
    29.             "com.genymotion.clipboardproxy", "com.uc.xxzs.keyboard", "com.uc.xxzs", "com.blue.huang17.agent", "com.blue.huang17.launcher",
    30.             "com.blue.huang17.ime", "com.microvirt.guide", "com.microvirt.market", "com.microvirt.memuime", "cn.itools.vm.launcher",
    31.             "cn.itools.vm.proxy", "cn.itools.vm.softkeyboard", "cn.itools.avdmarket", "com.syd.IME", "com.bignox.app.store.hd",
    32.             "com.bignox.launcher", "com.bignox.app.phone", "com.bignox.app.noxservice", "com.android.noxpush", "com.haimawan.push",
    33.             "me.haima.helpcenter", "com.windroy.launcher", "com.windroy.superuser", "com.windroy.launcher", "com.windroy.ime",
    34.             "com.android.flysilkworm", "com.android.emu.inputservice", "com.tiantian.ime", "com.microvirt.launcher", "me.le8.androidassist",
    35.             "com.vphone.helper", "com.vphone.launcher", "com.duoyi.giftcenter.giftcenter"};
    36.  
    37.     private static final String[] FILES = {"/data/data/com.android.flysilkworm", "/data/data/com.bluestacks.filemanager"};
    38.  
    39.     public static String checkFeaturesByHardware(Context context) {
    40.         String result = "";
    41.         String hardware = getProperty("ro.hardware");
    42.         if (null == hardware)
    43.             return "unknown";
    44.         String tempValue = hardware.toLowerCase();
    45.         Log.d(TAG,tempValue);
    46.         if(tempValue.startsWith("cancro")){
    47.             result = "MUMU模拟器";
    48.         }else if(tempValue.contains("nox")){
    49.             result = "夜神模拟器";
    50.         }else if(tempValue.equals("android_x86")){
    51.             result= "雷电模拟器";
    52.         }else{
    53.             List pathList = getInstalledSimulatorPackages(context);
    54.             result =  getSimulatorBrand(pathList);
    55.         }
    56.         return result;
    57.     }
    58.  
    59.     private static String getProperty(String propName) {
    60.         String value = null;
    61.         Object roSecureObj;
    62.         try {
    63.             roSecureObj = Class.forName("android.os.SystemProperties")
    64.                     .getMethod("get", String.class)
    65.                     .invoke(null, propName);
    66.             if (roSecureObj != null) value = (String) roSecureObj;
    67.         } catch (Exception e) {
    68.             value = null;
    69.         } finally {
    70.             return value;
    71.         }
    72.     }
    73.  
    74.  
    75.     private static List getInstalledSimulatorPackages(Context context) {
    76.         ArrayList localArrayList = new ArrayList();
    77.         try {
    78.             for (int i = 0; i < PKG_NAMES.length; i++)
    79.                 try {
    80.                     context.getPackageManager().getPackageInfo(PKG_NAMES[i], PackageManager.GET_ACTIVITIES);
    81.                     localArrayList.add(PKG_NAMES[i]);
    82.                 } catch (PackageManager.NameNotFoundException localNameNotFoundException) {
    83.                 }
    84.             if (localArrayList.size() == 0) {
    85.                 for (int i = 0; i < FILES.length; i++) {
    86.                     if (new File(FILES[i]).exists())
    87.                         localArrayList.add(FILES[i]);
    88.                 }
    89.             }
    90.         } catch (Exception e) {
    91.             e.printStackTrace();
    92.         }
    93.         return localArrayList;
    94.     }
    95.  
    96.     private static String getSimulatorBrand(List list) {
    97.         if (list.size() == 0)
    98.             return "";
    99.         String pkgName = list.get(0);
    100.         if (pkgName.contains("mumu")) {
    101.             return "mumu";
    102.         } else if (pkgName.contains("ami")) {
    103.             return "AMIDuOS";
    104.         } else if (pkgName.contains("bluestacks")) {
    105.             return "蓝叠";
    106.         } else if (pkgName.contains("kaopu001") || pkgName.contains("tiantian")) {
    107.             return "天天";
    108.         } else if (pkgName.contains("kpzs")) {
    109.             return "靠谱助手";
    110.         } else if (pkgName.contains("genymotion")) {
    111.             if (Build.MODEL.contains("iTools")) {
    112.                 return "iTools";
    113.             } else if ((Build.MODEL.contains("ChangWan"))) {
    114.                 return "畅玩";
    115.             } else {
    116.                 return "genymotion";
    117.             }
    118.         } else if (pkgName.contains("uc")) {
    119.             return "uc";
    120.         } else if (pkgName.contains("blue")) {
    121.             return "blue";
    122.         } else if (pkgName.contains("microvirt")) {
    123.             return "逍遥";
    124.         } else if (pkgName.contains("itools")) {
    125.             return "itools";
    126.         } else if (pkgName.contains("syd")) {
    127.             return "手游岛";
    128.         } else if (pkgName.contains("bignox")) {
    129.             return "夜神";
    130.         } else if (pkgName.contains("haimawan")) {
    131.             return "海马玩";
    132.         } else if (pkgName.contains("windroy")) {
    133.             return "windroy";
    134.         } else if (pkgName.contains("flysilkworm")) {
    135.             return "雷电";
    136.         } else if (pkgName.contains("emu")) {
    137.             return "emu";
    138.         } else if (pkgName.contains("le8")) {
    139.             return "le8";
    140.         } else if (pkgName.contains("vphone")) {
    141.             return "vphone";
    142.         } else if (pkgName.contains("duoyi")) {
    143.             return "多益";
    144.         }
    145.         return "";
    146.     }
    147.  
    148.  
    149.     public static boolean isEmulator(Context context){
    150.               return notHasLightSensorManager(context)
    151.                 ||isFeatures()
    152.                 ||checkIsNotRealPhone()
    153.                 ||checkPipes() ||isYeshenEmulator();
    154.     }
    155.  
    156.  
    157.     public static String getPhoneBrand(){
    158.         return android.os.Build.BRAND;
    159.     }
    160.  
    161.     public static String getPhoneModel(){
    162.         return  android.os.Build.MODEL;
    163.     }
    164.  
    165.     /*
    166.      *用途:判断蓝牙是否有效来判断是否为模拟器
    167.      *返回:true 为模拟器
    168.      */
    169. //    private static boolean notHasBlueTooth() {
    170. //        BluetoothAdapter ba = BluetoothAdapter.getDefaultAdapter();
    171. //        if (ba == null) {
    172. //            return true;
    173. //        } else {
    174. //            // 如果有蓝牙不一定是有效的。获取蓝牙名称，若为null 则默认为模拟器
    175. //            String name = ba.getName();
    176. //            if (TextUtils.isEmpty(name)) {
    177. //                return true;
    178. //            } else {
    179. //                return false;
    180. //            }
    181. //        }
    182. //    }
    183.  
    184.     /*
    185.      *用途:依据是否存在光传感器来判断是否为模拟器
    186.      *返回:true 为模拟器
    187.      */
    188.     private static Boolean notHasLightSensorManager(Context context) {
    189.         SensorManager sensorManager = (SensorManager) context.getSystemService(context.SENSOR_SERVICE);
    190.         Sensor sensor8 = sensorManager.getDefaultSensor(Sensor.TYPE_LIGHT); //光
    191.         if (null == sensor8) {
    192.             return true;
    193.         } else {
    194.             return false;
    195.         }
    196.     }
    197.  
    198.     /*
    199.      *用途:根据部分特征参数设备信息来判断是否为模拟器
    200.      *返回:true 为模拟器
    201.      */
    202.     private static boolean isFeatures() {
    203.         return Build.FINGERPRINT.startsWith("generic")
    204.                 || Build.FINGERPRINT.toLowerCase().contains("vbox")
    205.                 || Build.FINGERPRINT.toLowerCase().contains("test-keys")
    206.                 || Build.MODEL.contains("google_sdk")
    207.                 || Build.MODEL.contains("Emulator")
    208.                 || Build.MODEL.contains("Android SDK built for x86")
    209.                 || Build.MANUFACTURER.contains("Genymotion")
    210.                 || (Build.BRAND.startsWith("generic") && Build.DEVICE.startsWith("generic"))
    211.                 || "google_sdk".equals(Build.PRODUCT);
    212.     }
    213.  
    214.     /*
    215.      *用途:根据CPU是否为电脑来判断是否为模拟器
    216.      *返回:true 为模拟器
    217.      */
    218.     private static boolean checkIsNotRealPhone() {
    219.         String cpuInfo = readCpuInfo();
    220.         if ((cpuInfo.contains("intel") || cpuInfo.contains("amd"))) {
    221.             return true;
    222.         }
    223.         return false;
    224.     }
    225.  
    226.     /*
    227.      *用途:根据CPU是否为电脑来判断是否为模拟器(子方法)
    228.      *返回:String
    229.      */
    230.     private static String readCpuInfo() {
    231.         String result = "";
    232.         try {
    233.             String[] args = {"/system/bin/cat", "/proc/cpuinfo"};
    234.             ProcessBuilder cmd = new ProcessBuilder(args);
    235.  
    236.             Process process = cmd.start();
    237.             StringBuffer sb = new StringBuffer();
    238.             String readLine = "";
    239.             BufferedReader responseReader = new BufferedReader(new InputStreamReader(process.getInputStream(), "utf-8"));
    240.             while ((readLine = responseReader.readLine()) != null) {
    241.                 sb.append(readLine);
    242.             }
    243.             responseReader.close();
    244.             result = sb.toString().toLowerCase();
    245.         } catch (IOException ex) {
    246.         }
    247.         return result;
    248.     }
    249.  
    250.     /*
    251.      *用途:检测模拟器的特有文件
    252.      *返回:true 为模拟器
    253.      */
    254.     private static String[] known_pipes = {"/dev/socket/qemud", "/dev/qemu_pipe"};
    255.     private static boolean checkPipes() {
    256.         for (int i = 0; i < known_pipes.length; i++) {
    257.             String pipes = known_pipes[i];
    258.             File qemu_socket = new File(pipes);
    259.             if (qemu_socket.exists()) {
    260.                 Log.v("Result:", "Find pipes!");
    261.                 return true;
    262.             }
    263.         }
    264.         Log.i("Result:", "Not Find pipes!");
    265.         return false;
    266.     }
    267.  
    268.     //****************适配夜神模拟器*******************
    269.     //获取 cpu 信息
    270.     private static String getCpuInfo() {
    271.         String[] abis = new String[]{};
    272.         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
    273.             abis = Build.SUPPORTED_ABIS;
    274.         } else {
    275.             abis = new String[]{Build.CPU_ABI, Build.CPU_ABI2};
    276.         }
    277.         StringBuilder abiStr = new StringBuilder();
    278.         for (String abi : abis) {
    279.             abiStr.append(abi);
    280.             abiStr.append(',');
    281.         }
    282.  
    283.         return abiStr.toString();
    284.     }
    285.  
    286.     // 通过cpu判断是否模拟器 ,适配夜神
    287.     private static boolean isYeshenEmulator() {
    288.         String abiStr = getCpuInfo();
    289.         if (abiStr != null && abiStr.length() > 0) {
    290.             boolean isSupportX86 = false;
    291.             boolean isSupportArm = false;
    292.  
    293.             if (abiStr.contains("x86_64") || abiStr.contains("x86")) {
    294.                 isSupportX86 = true;
    295.             }
    296.             if (abiStr.contains("armeabi") || abiStr.contains("armeabi-v7a") || abiStr.contains("arm64-v8a")) {
    297.                 isSupportArm = true;
    298.             }
    299.             if (isSupportX86 && isSupportArm) {
    300.                 //同时拥有X86和arm的判断为模拟器。
    301.                 return true;
    302.             }
    303.         }
    304.         return false;
    305.     }
    306.  
    307.  
    308. }

    使用

    1. boolean flag = EmutorUtils.isEmulator(MainActivity.this);
    2.         Toast.makeText(MainActivity.this,"是否是模拟器:"+flag,Toast.LENGTH_SHORT).show();
    3.  
    4.         button.setOnClickListener(new View.OnClickListener() {
    5.             @Override
    6.             public void onClick(View v) {
    7.                 String name = EmutorUtils.checkFeaturesByHardware(MainActivity.this);
    8.                 String brand = EmutorUtils.getPhoneBrand();
    9.                 String model = EmutorUtils.getPhoneModel();
    10.                 String result = "name:"+name+"brand:"+brand+"model:"+model;
    11.                 Toast.makeText(MainActivity.this,result,Toast.LENGTH_SHORT).show();
    12.             }
    13.         });

    效果图

    mumu

    雷电

    逍遥

    夜神

    官方AVD(用这个玩游戏基本没有)

    参考 

    http://dxtdbj.com/article.php?id=268
    https://cloud.tencent.com/developer/article/2019963 

  • 相关阅读:
    docker笔记
    下一个风口在哪里？云计算：未来十年最有潜力行业！
    在 Django Model ViewSet 中实现多对多字段的搜索
    数字化转型将为企业带来什么样的变革？
    【AI应用】NVIDIA GeForce RTX 1080Ti的详情参数
    DSL查询文档
    oracle-buffer cache
    【JavaScript复习十一】数组内置对象方法一
    Java基础---第五篇
    可视化模块
  • 原文地址：https://blog.csdn.net/qq_34123324/article/details/132827002