Xp新机

 /**
     * 不设置Null默认为原类型
     */
    class MyDevicesInfoClass {

        public String IMEI = null;
        public String DeviceID = null;
        public String AndroidID = null;

         //获取经纬度的方法
         //        Location location = locationManager.getLastKnownLocation(locationProvider);
         //        Toast.makeText(this, location.getLongitude() + " " + location.getLatitude() + "",  Toast.LENGTH_SHORT).show();
              

        //经度
        public double Longitude = -1;
        //纬度
        public double Latitude = -1;


        //手机号
        public String phoneNum = null;
        //安卓版本号SDK的
        public String BuildID = null;
        //c3-miui-ota-bd49.bj
        public String BuildHost = null;

        //wifi SSID （wifi名字）
        public String WifiSSID = null;
        //wifi Mac地址
        public String WifiMac = null;
        //wifi物理地址
        public String WifiBSSID = null;

        public String BluetoothMac = null;
        public String productName = null;
        public String changshang = null;
        public String xinghao = null;
        public String AndroidVersion = null;

        public int SDKVersion = -1;
        //CPU 版本号 "arm64-v8a"
        public String CPU_ABI = null;
        //屏幕宽
        public String WScreen = null;
        public String HScreen = null;

        public String HostIP = null;

        //SIM卡唯一标识ID
        public String SIMCodeID = null;
        //SIM的IMSI
        public String SIMIMSI = null;
        //SIM卡状态 正常状态是 5
        public int SIMIStatus = -1;

        //运营商ID SIM卡提供商代码 46000           46002移动  46001中国联通  46003电信
        public String SIMCarrieroperatorID = null;
        //运营商名字 中国联通 中国移动
        public String SIMCarrieroperatorName = null;
        //国家码
        public String SIMCountryCode = null;
        //网络运营商 中国联通 中国移动
        public String SIMNetCarrieroperator = null;


        //这个是 系统的 版本号 比如小米6系统的 版本号是 7.12.7 安卓7 12.7号版本
        public String Build_VERSION_INCREMENTAL = null;
        //c92499ea
        public String Build_VERSION_SERIAL = null;
        //REL
        public String Build_VERSION_CODENAME = null;
        //qcom 高通意思
        public String Build_VERSION_HARDWARE = null;
        //Xiaomi
        public String Build_VERSION_MANUFACTURER = null;


        //这个和厂商一样也是 Xiaomi
        public String Build_VERSION_BRAND = null;
        //unknown
        public String Build_VERSION_BOOTLOADER = null;
        //unknown
        public String Build_VERSION_RADIO = null;
        //release-keys build的版本信息
        public String Build_VERSION_TAGS = null;
        //1512592081000 时间戳
        public long Build_VERSION_TIME = -1;
        //user
        public String Build_VERSION_TYPE = null;
        //builder
        public String Build_VERSION_USER = null;
        //arm64-v8a
        public String Build_VERSION_CPU_ABI = null;
        //msm8998
        public String Build_VERSION_BOARD = null;
        //sagit
        public String Build_VERSION_DEVICE = null;
        //sagit
        public String Build_VERSION_PRODUCT = null;
        //c3-miui-ota-bd49.bj
        public String Build_VERSION_HOST = null;
        //NMF26X
        public String Build_VERSION_DISPLAY = null;
        //SDK版本号 25 这种
        public String Build_VERSION_SDK = null;
        //硬件ID（Xiaomi/cmi/cmi:10/QKQ1.191117）
        public String Build_VERSION_FingerPrint = null;
}
}

 try {
                    RposedHelpers.findAndHookMethod(BuildClass, "getString",
                            String.class,
                            new RC_MethodHook() {
                                @Override
                                protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                                    super.afterHookedMethod(param);
                                    String arg = (String) param.args[0];
                                    switch (arg) {
                                        case "ro.product.model":
                                            //MI 9
                                            if (finalDevicesInfo.xinghao != null) {
                                                param.setResult(finalDevicesInfo.xinghao);
                                            }
                                            Log.e(TAG, "获取手机model 返回的 结果是  " + param.getResult());

                                            break;
                                        //SDK版本号
                                        case "ro.build.version.sdk":
                                            //MI 9
                                            if (finalDevicesInfo.Build_VERSION_SDK != null) {
                                                param.setResult(finalDevicesInfo.Build_VERSION_SDK);
                                            }
                                            Log.e(TAG, "获取手机model 返回的 结果是  " + param.getResult());

                                            break;
                                        case "ro.product.brand": {
                                            //Xiaomi
                                            if (finalDevicesInfo.changshang != null) {
                                                param.setResult(finalDevicesInfo.changshang);
                                            }
                                            Log.e(TAG, "获取 手机 品牌信息  返回的结果 是    " + param.getResult());
                                            break;
                                        }
                                        case "ro.product.name":
                                            //cepheus
                                            if (finalDevicesInfo.productName != null) {
                                                param.setResult(finalDevicesInfo.productName);
                                            }
                                            Log.e(TAG, "获取手机产品名字返回的结果是   " + param.getResult());
                                            break;
                                        case "ro.build.id": {
                                            if (finalDevicesInfo.BuildID != null) {
                                                param.setResult(finalDevicesInfo.BuildID);
                                            }
                                            Log.e(TAG, "获取手机安卓版本号返回的结果是   " + param.getResult());
                                            break;
                                        }
                                        case "no.such.thing":
                                            //param.setResult(System.currentTimeMillis() + "");
                                            Log.e(TAG, "获取手机序列号 " + param.getResult());
                                            break;
                                        case "ro.build.host":
                                            if (finalDevicesInfo.BuildHost != null) {
                                                param.setResult(finalDevicesInfo.BuildHost);
                                            }
                                            Log.e(TAG, "获取 手机 BuildHost" + param.getResult().toString());
                                            break;
                                        //7.1.1
                                        case "ro.build.version.release": {
                                            if (finalDevicesInfo.AndroidVersion != null) {
                                                param.setResult(finalDevicesInfo.AndroidVersion);
                                            }
                                            Log.e(TAG, "获取 安卓版本号  返回结果是  " + param.getResult());
                                            break;
                                        }
                                        case "ro.product.cpu.abi": {
                                            if (finalDevicesInfo.CPU_ABI != null) {
                                                param.setResult(finalDevicesInfo.CPU_ABI);
                                            }
                                            Log.e(TAG, "获取 Cpu  返回结果是  " + param.getResult());
                                            break;
                                        }
                                        case "ro.product.manufacturer": {
                                            if (finalDevicesInfo.Build_VERSION_MANUFACTURER != null) {
                                                param.setResult(finalDevicesInfo.Build_VERSION_MANUFACTURER);
                                            }
                                            Log.e(TAG, "获取 ro.product.manufacturer  返回结果是  " + param.getResult());
                                            break;
                                        }
                                        //设备指纹信息
                                        case "ro.build.fingerprint": {
                                            if (finalDevicesInfo.Build_VERSION_FingerPrint != null) {
                                                param.setResult(finalDevicesInfo.Build_VERSION_FingerPrint);
                                            }
                                            Log.e(TAG, "获取 ro.build.fingerprint  返回结果是  " + param.getResult());
                                            break;
                                        }

                                    }

                                }
                            }
                    );
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

            TelephonyManagerClass = getMyClass(classLoader, TelephonyManager.class.getName());

            if (TelephonyManagerClass != null) {

                try {
                    RposedHelpers.findAndHookMethod(TelephonyManagerClass, "getDeviceId", new RC_MethodHook() {
                        @Override
                        protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                            super.afterHookedMethod(param);
                            if (finalDevicesInfo.DeviceID != null) {
                                param.setResult(finalDevicesInfo.DeviceID);
                            }
                            Log.e(TAG, "获取getDeviceId被调用了返回的 结果 是 " + param.getResult());
                        }
                    });
                } catch (Exception e) {
                    e.printStackTrace();
                    Log.e(TAG, "获取getDeviceId被调用了返回的  error" + e.getMessage());

                }
                try {
                    RposedHelpers.findAndHookMethod(TelephonyManagerClass, "getImei", new RC_MethodHook() {
                        @Override
                        protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                            super.afterHookedMethod(param);
                            if (finalDevicesInfo.IMEI != null) {
                                param.setResult(finalDevicesInfo.IMEI);
                            }
                            Log.e(TAG, "获取getImei被调用了  返回的 结果 是 " + param.getResult());
                        }
                    });
                } catch (Exception e) {
                    e.printStackTrace();
                    Log.e(TAG, "获取getImei被调用了  error" + e.getMessage());

                }
                try {
                    RposedHelpers.findAndHookMethod(TelephonyManagerClass, "getLine1Number", new RC_MethodHook() {
                        @Override
                        protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                            super.afterHookedMethod(param);
                            if (finalDevicesInfo.phoneNum != null) {
                                param.setResult(finalDevicesInfo.phoneNum);
                            }
                            Log.e(TAG, "获取手机号被调用  getLine1Number" + param.getResult());
                        }
                    });

                } catch (Exception e) {
                    e.printStackTrace();
                    Log.e(TAG, "获取手机号被调用  error" + e.getMessage());

                }
            }

//            SettingsClass = Class.forName("android.provider.Settings", true, classLoader);
//
//            if (SettingsClass == null) {
//                SettingsClass = Class.forName("android.provider.Settings");
//            }

            SettingsClass = getMyClass(classLoader, "android.provider.Settings");
            if (SettingsClass != null) {
                //10.0版本存在问题
                Method getStringMethod = null;
                try {
                    //先判断是否存在指定方法在进行Hook
                    getStringMethod = SettingsClass.getDeclaredMethod("getString", ContentResolver.class, String.class);
                    getStringMethod.setAccessible(true);
                } catch (Throwable e) {
                    e.printStackTrace();
                }
                try {
                    if (getStringMethod != null) {
                        RposedHelpers.findAndHookMethod(SettingsClass,
                                "getString",
                                ContentResolver.class,
                                String.class,
                                new RC_MethodHook() {
                                    @Override
                                    protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                                        super.afterHookedMethod(param);
                                        if (finalDevicesInfo.DeviceID != null) {
                                            param.setResult(finalDevicesInfo.DeviceID);
                                        }
                                        Log.e(TAG, "获取getDeviceId SettingsClass  getString" + param.getResult());
                                    }
                                });
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                    Log.e(TAG, "SettingsClass  error" + e.getMessage());

                }
            }


            Settings_Secure = getMyClass(classLoader, Settings.Secure.class.getName());
            if (Settings_Secure != null) {
                RposedHelpers.findAndHookMethod(Settings_Secure,
                        "getString",
                        ContentResolver.class,
                        String.class, new RC_MethodHook() {
                            @Override
                            protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                                super.afterHookedMethod(param);
                                //这个也是一个AndroidID 可以在不申请权限的情况进行获取 不过每次Root或者刷机都会变化
                                if (finalDevicesInfo.AndroidID != null) {
                                    param.setResult(finalDevicesInfo.AndroidID);
                                }
                                Log.e(TAG, "Settings.Secure AndroidID 被调用 " + param.getResult());
                            }
                        });
            }

//            InetAddressClass = Class.forName("java.net.InetAddress", true, classLoader);
//
//            if (InetAddressClass == null) {
//                InetAddressClass = getClass(classLoader,"java.net.InetAddress");
//            }
            InetAddressClass = getMyClass(classLoader, "java.net.InetAddress");
            if (InetAddressClass != null) {
                try {
                    RposedHelpers.findAndHookMethod(InetAddressClass,
                            "getHostAddress",
                            new RC_MethodHook() {
                                @Override
                                protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                                    super.afterHookedMethod(param);
                                    if (finalDevicesInfo.HostIP != null) {
                                        param.setResult(finalDevicesInfo.HostIP);
                                    }
                                    //192.168.123.71
                                    Log.e(TAG, "获取IP(getHostAddress)地址  被调用了 返回结果是 " + param.getResult());
                                }
                            });
                } catch (Exception e) {
                    e.printStackTrace();
                    Log.e(TAG, "InetAddressClass  error" + e.getMessage());

                }
            }
            try {
                //Hook 获取mac地址
                RposedHelpers.findAndHookMethod(WifiInfo.class, "getMacAddress", new RC_MethodHook() {
                    @Override
                    protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                        super.afterHookedMethod(param);
                        if (finalDevicesInfo.WifiMac != null) {
                            param.setResult(finalDevicesInfo.WifiMac);
                        }
                        Log.e(TAG, "获取MAC getMacAddress 被调用了 返回结果是 " + param.getResult());

                    }
                });
            } catch (Exception e) {
                e.printStackTrace();
                Log.e(TAG, "获取MAC  getMacAddress" + e.getMessage());

            }
            try {
                if (Build.VERSION.SDK_INT >= 24) {
                    RposedHelpers.findAndHookMethod(DevicePolicyManager.class,
                            "getWifiMacAddress",
                            ComponentName.class, new RC_MethodHook() {
                                @Override
                                protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                                    super.afterHookedMethod(param);
                                    if (finalDevicesInfo.WifiMac != null) {
                                        param.setResult(finalDevicesInfo.WifiMac);
                                    }
                                    Log.e(TAG, "获取MAC getWifiMacAddress 被调用了 返回结果是 " + param.getResult());
                                }
                            });
                }
            } catch (Throwable e) {
                e.printStackTrace();
                Log.e(TAG, "获取MAC  getMacAddress" + e.getMessage());

            }
            //getSubscriberId  这个方法是获取SIM卡唯一标识
            try {
                RposedHelpers.findAndHookMethod(TelephonyManager.class, "getSubscriberId", new RC_MethodHook() {
                    @Override
                    protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                        super.afterHookedMethod(param);
                        if (finalDevicesInfo.SIMCodeID != null) {
                            param.setResult(finalDevicesInfo.SIMCodeID);
                        }
                        Log.e(TAG, "获取SIM卡ID   被调用了 返回结果是 " + param.getResult());

                    }
                });
            } catch (Exception e) {
                e.printStackTrace();
                Log.e(TAG, "获取SIM卡ID  error" + e.getMessage());

            }
            try {
                //运营商ID 46002
                RposedHelpers.findAndHookMethod(TelephonyManager.class, "getSimOperator", new RC_MethodHook() {
                    @Override
                    protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                        super.afterHookedMethod(param);
                        if (finalDevicesInfo.SIMCarrieroperatorID != null) {
                            param.setResult(finalDevicesInfo.SIMCarrieroperatorID);
                        }
                        Log.e(TAG, "获取SIM卡运营商ID   被调用了 返回结果是 " + param.getResult());
                    }
                });
            } catch (Exception e) {
                Log.e(TAG, "获取SIM卡运营商ID  error" + e.getMessage());
            }


            //Hook 获取 ICCID
            try {
                RposedHelpers.findAndHookMethod(TelephonyManager.class, "getSimSerialNumber", new RC_MethodHook() {
                    @Override
                    protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                        super.afterHookedMethod(param);
                        String mac = getIMEI();
                        param.setResult(mac);
                        Log.e(TAG, "获取 getSimSerialNumber（ICCID）  被调用了 返回结果是 " + mac);

                    }
                });
            } catch (Exception e) {
                e.printStackTrace();
                Log.e(TAG, "getSimSerialNumber（ICCID）  error" + e.getMessage());
            }
            //Hook MSISDN
            try {
                RposedHelpers.findAndHookMethod(TelephonyManager.class, "getLine1Number", new RC_MethodHook() {
                    @Override
                    protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                        super.afterHookedMethod(param);
                        param.setResult("");
                        Log.e(TAG, "获取 getLine1Number（MSISDN）  ");

                    }
                });
            } catch (Exception e) {
                e.printStackTrace();
                Log.e(TAG, "getLine1Number  error" + e.getMessage());

            }
            try {
                //Hook 运营商名字
                RposedHelpers.findAndHookMethod(TelephonyManager.class, "getSimOperatorName", new RC_MethodHook() {
                    @Override
                    protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                        super.afterHookedMethod(param);
                        if (finalDevicesInfo.SIMCarrieroperatorName != null) {
                            param.setResult(finalDevicesInfo.SIMCarrieroperatorName);
                        }
                        Log.e(TAG, "获取运营商名字 getSimOperatorName  " + param.getResult());

                    }
                });
            } catch (Exception e) {
                Log.e(TAG, "获取运营商名字 getSimOperatorName  " + e.getMessage());
            }

            try {
                //获取SIM卡状态
                RposedHelpers.findAndHookMethod(TelephonyManager.class, "getSimState", new RC_MethodHook() {
                    @Override
                    protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                        super.afterHookedMethod(param);
                        if (finalDevicesInfo.SIMIStatus != -1) {
                            param.setResult(finalDevicesInfo.SIMIStatus);
                        }
                        Log.e(TAG, "获取SIM卡状态这种 SIMIStatus  " + param.getResult());
                    }
                });
            } catch (Exception e) {
                e.printStackTrace();
                Log.e(TAG, "获取SIM卡状态这种 error  " + e.getMessage());
            }


            try {
                //运营商国别 cn 是中国
                RposedHelpers.findAndHookMethod(TelephonyManager.class, "getSimCountryIso", new RC_MethodHook() {
                    @Override
                    protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                        super.afterHookedMethod(param);
                        if (finalDevicesInfo.SIMCountryCode != null) {
                            param.setResult(finalDevicesInfo.SIMCountryCode);
                        }
                        Log.e(TAG, "获取运营商国别 cn 这种 SIMCountryCode  " + param.getResult());

                    }
                });
            } catch (Exception e) {
                e.printStackTrace();
                Log.e(TAG, "获取运营商国别 error  " + e.getMessage());
            }


            //TelephonyManager telephonyManager = ((TelephonyManager) .getSystemService(Context.TELEPHONY_SERVICE));

            Class TelephonyManagerClass = getMyClass(classLoader, TelephonyManager.class.getName());

            if (TelephonyManagerClass != null) {
                //根据设备修改补充
                try {
                    RposedHelpers.findAndHookMethod(TelephonyManagerClass, "getDeviceId", new RC_MethodHook() {
                        @Override
                        protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                            super.afterHookedMethod(param);
                            if (finalDevicesInfo.DeviceID != null) {
                                param.setResult(finalDevicesInfo.DeviceID);
                            }
                            Log.e(TAG, "小于22版本号的 GSMPhone 设备ID 获取" + param.getResult());
                        }
                    });
                } catch (Exception e) {
                    e.printStackTrace();

                }
            }

            //PhoneSubInfo
//            public String getDeviceId() {
//                mContext.enforceCallingOrSelfPermission(READ_PHONE_STATE, "Requires READ_PHONE_STATE");
//                return mPhone.getDeviceId();
//            }
//            Class PhoneSubInfoClass = getMyClass(classLoader);
//            if (PhoneSubInfoClass != null) {
//                try {
//                    RposedHelpers.findAndHookMethod(PhoneSubInfoClass, "getDeviceId",
//                            new RC_MethodHook() {
//                        @Override
//                        protected void afterHookedMethod(MethodHookParam param) throws Throwable {
//                            super.afterHookedMethod(param);
//                            if (finalDevicesInfo.IMEI != null) {
//                                param.setResult(finalDevicesInfo.IMEI);
//                            }
//                            Log.e(TAG, "PhoneSubInfo 设备ID 获取" + param.getResult());
//                        }
//                    });
//                } catch (Exception e) {
//                    e.printStackTrace();
//                }
//            }
            Class PhoneProxyClass = getMyClass(classLoader, "com.android.internal.telephony.PhoneProxy");
            if (PhoneProxyClass != null) {
                try {
                    RposedHelpers.findAndHookMethod(PhoneProxyClass, "getDeviceId", new RC_MethodHook() {
                        @Override
                        protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                            super.afterHookedMethod(param);
                            if (finalDevicesInfo.IMEI != null) {
                                param.setResult(finalDevicesInfo.IMEI);
                            }
                            Log.e(TAG, "PhoneProxy 设备ID 获取" + param.getResult());
                        }
                    });
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            Class WifiInfoClass = getMyClass(classLoader, WifiInfo.class.getName());
            if (WifiInfoClass != null) {
                try {
                    RposedHelpers.findAndHookMethod(WifiInfoClass, "getMacAddress", new RC_MethodHook() {
                        @Override
                        protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                            super.afterHookedMethod(param);
                            if (finalDevicesInfo.WifiMac != null) {
                                param.setResult(finalDevicesInfo.WifiMac);
                            }
                            Log.e(TAG, "getMacAddress Mac 地址 被调用  " + param.getResult());
                        }
                    });
                } catch (Exception e) {
                    e.printStackTrace();
                }
                try {
                    // SSID：WIFI名称
                    RposedHelpers.findAndHookMethod(WifiInfoClass, "getSSID", new RC_MethodHook() {
                        @Override
                        protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                            super.afterHookedMethod(param);

                            if (finalDevicesInfo.WifiSSID != null) {
                                param.setResult(finalDevicesInfo.WifiSSID);
                            }
                            Log.e(TAG, "wifi名称   getSSID 被调用  " + param.getResult());
                        }
                    });
                } catch (Exception e) {
                    e.printStackTrace();
                }
                try {

                    //getBSSID wifi的物理地址
                    RposedHelpers.findAndHookMethod(WifiInfoClass, "getBSSID", new RC_MethodHook() {
                        @Override
                        protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                            super.afterHookedMethod(param);

                            if (finalDevicesInfo.WifiBSSID != null) {
                                param.setResult(finalDevicesInfo.WifiBSSID);
                            }
                            Log.e(TAG, "wifi物理地址 getBSSID  被调用  " + param.getResult());
                        }
                    });
                } catch (Exception e) {
                    e.printStackTrace();
                }

            }
            Class DevicePolicyManagerClass = getMyClass(classLoader, "android.app.admin.DevicePolicyManager");
            if (DevicePolicyManagerClass != null) {
                try {
                    Method getWifiMacAddress = DevicePolicyManagerClass.getDeclaredMethod("getWifiMacAddress",
                            ComponentName.class);
                    if (getWifiMacAddress != null) {
                        RposedHelpers.findAndHookMethod(DevicePolicyManagerClass,
                                "getWifiMacAddress",
                                ComponentName.class,
                                new RC_MethodHook() {
                                    @Override
                                    protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                                        super.afterHookedMethod(param);
                                        //param.setResult(imei);
                                        Log.e(TAG, "getWifiMacAddress 地址 被调用");
                                    }
                                });
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }


            //Hook 蓝牙
            Class BluetoothAdapterClass = getMyClass(classLoader, "android.bluetooth.BluetoothAdapter");
            if (BluetoothAdapterClass != null) {
                try {
                    RposedHelpers.findAndHookMethod(BluetoothAdapterClass, "getAddress", new RC_MethodHook() {
                        @Override
                        protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                            super.afterHookedMethod(param);
                            if (finalDevicesInfo.BluetoothMac != null) {
                                param.setResult(finalDevicesInfo.BluetoothMac);
                            }
                            Log.e(TAG, "蓝牙Mac 被调用  " + param.getResult());
                        }
                    });
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

            //Hook经纬度
          //Location location = locationManager.getLastKnownLocation(locationProvider);
//        Toast.makeText(this, location.getLongitude() + " " + location.getLatitude() + "", Toast.LENGTH_SHORT).show();
            Class LocationClass = getMyClass(classLoader, Location.class.getName());
            if(LocationClass!=null){
                RposedHelpers.findAndHookMethod(LocationClass, "getLongitude", new RC_MethodHook() {
                    @Override
                    protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                        super.afterHookedMethod(param);
                        if (finalDevicesInfo.Longitude != -1) {
                            param.setResult(finalDevicesInfo.Longitude);
                        }
                        Log.e(TAG, "获取经度被调用  " + param.getResult());
                    }
                });
                RposedHelpers.findAndHookMethod(LocationClass, "getLatitude", new RC_MethodHook() {
                    @Override
                    protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                        super.afterHookedMethod(param);
                        if (finalDevicesInfo.Latitude != -1) {
                            param.setResult(finalDevicesInfo.Latitude);
                        }
                        Log.e(TAG, "获取纬度被调用  " + param.getResult());
                    }
                });
            }


            //静态变量重新赋值
            if (finalDevicesInfo.SDKVersion != -1) {
                try {
                    RposedHelpers.setStaticObjectField(Build.VERSION.class, "SDK_INT", finalDevicesInfo.SDKVersion);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            //SDK版本号
            if (finalDevicesInfo.Build_VERSION_SDK != null) {
                try {
                    RposedHelpers.setStaticObjectField(Build.VERSION.class, "SDK", finalDevicesInfo.Build_VERSION_SDK);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

            //获取安卓版本号的
            if (finalDevicesInfo.AndroidVersion != null) {
                try {
                    RposedHelpers.setStaticObjectField(Build.VERSION.class, "RELEASE", finalDevicesInfo.AndroidVersion);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

            //这个是系统MIUI的版本号  比如 小米6的   7.12.7
            if (finalDevicesInfo.Build_VERSION_INCREMENTAL != null) {
                try {
                    RposedHelpers.setStaticObjectField(Build.VERSION.class, "INCREMENTAL", finalDevicesInfo.Build_VERSION_INCREMENTAL);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            //CODENAME: REL
            if (finalDevicesInfo.Build_VERSION_CODENAME != null) {
                try {
                    RposedHelpers.setStaticObjectField(Build.VERSION.class, "CODENAME", finalDevicesInfo.Build_VERSION_CODENAME);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            //c92499ea
            if (finalDevicesInfo.Build_VERSION_SERIAL != null) {
                try {
                    RposedHelpers.setStaticObjectField(Build.class, "SERIAL", finalDevicesInfo.Build_VERSION_SERIAL);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            //Xiaomi
            if (finalDevicesInfo.Build_VERSION_MANUFACTURER != null) {
                try {
                    RposedHelpers.setStaticObjectField(Build.class, "MANUFACTURER", finalDevicesInfo.Build_VERSION_MANUFACTURER);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

            //qcom
            if (finalDevicesInfo.Build_VERSION_HARDWARE != null) {
                try {
                    RposedHelpers.setStaticObjectField(Build.class, "HARDWARE", finalDevicesInfo.Build_VERSION_HARDWARE);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            //Xiaomi
            if (finalDevicesInfo.Build_VERSION_BRAND != null) {
                try {
                    RposedHelpers.setStaticObjectField(Build.class, "BRAND", finalDevicesInfo.Build_VERSION_BRAND);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

            if (finalDevicesInfo.Build_VERSION_BOOTLOADER != null) {
                try {
                    RposedHelpers.setStaticObjectField(Build.class, "BOOTLOADER", finalDevicesInfo.Build_VERSION_BOOTLOADER);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

            if (finalDevicesInfo.Build_VERSION_RADIO != null) {
                try {
                    RposedHelpers.setStaticObjectField(Build.class, "RADIO", finalDevicesInfo.Build_VERSION_RADIO);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

            if (finalDevicesInfo.Build_VERSION_TAGS != null) {
                try {
                    RposedHelpers.setStaticObjectField(Build.class, "TAGS", finalDevicesInfo.Build_VERSION_TAGS);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

            if (finalDevicesInfo.Build_VERSION_TIME != -1) {
                try {
                    RposedHelpers.setStaticObjectField(Build.class, "TIME", finalDevicesInfo.Build_VERSION_TIME);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            if (finalDevicesInfo.xinghao != null) {
                try {
                    RposedHelpers.setStaticObjectField(Build.class, "MODEL", finalDevicesInfo.xinghao);
                    Log.e(TAG, "设置型号成功  " +finalDevicesInfo.xinghao);

                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            if (finalDevicesInfo.Build_VERSION_TYPE != null) {
                try {
                    RposedHelpers.setStaticObjectField(Build.class, "TYPE", finalDevicesInfo.Build_VERSION_TYPE);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

            if (finalDevicesInfo.Build_VERSION_USER != null) {
                try {
                    RposedHelpers.setStaticObjectField(Build.class, "USER", finalDevicesInfo.Build_VERSION_USER);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

            if (finalDevicesInfo.Build_VERSION_CPU_ABI != null) {
                try {
                    RposedHelpers.setStaticObjectField(Build.class, "CPU_ABI", finalDevicesInfo.Build_VERSION_CPU_ABI);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

            if (finalDevicesInfo.Build_VERSION_BOARD != null) {
                try {
                    RposedHelpers.setStaticObjectField(Build.class, "BOARD", finalDevicesInfo.Build_VERSION_BOARD);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            if (finalDevicesInfo.Build_VERSION_DEVICE != null) {
                try {
                    RposedHelpers.setStaticObjectField(Build.class, "DEVICE", finalDevicesInfo.Build_VERSION_DEVICE);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            if (finalDevicesInfo.Build_VERSION_PRODUCT != null) {
                try {
                    RposedHelpers.setStaticObjectField(Build.class, "PRODUCT", finalDevicesInfo.Build_VERSION_PRODUCT);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            if (finalDevicesInfo.Build_VERSION_HOST != null) {
                try {
                    RposedHelpers.setStaticObjectField(Build.class, "HOST", finalDevicesInfo.Build_VERSION_HOST);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            if (finalDevicesInfo.Build_VERSION_DISPLAY != null) {
                try {
                    RposedHelpers.setStaticObjectField(Build.class, "DISPLAY", finalDevicesInfo.Build_VERSION_DISPLAY);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

            if (finalDevicesInfo.Build_VERSION_FingerPrint != null) {
                try {
                    RposedHelpers.setStaticObjectField(Build.class, "FINGERPRINT", finalDevicesInfo.Build_VERSION_FingerPrint);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

            if (finalDevicesInfo.Build_VERSION_DISPLAY != null) {
                try {
                    RposedHelpers.setStaticObjectField(Build.class, "DISPLAY", finalDevicesInfo.Build_VERSION_DISPLAY);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

            //Hook宽高
            try {
                RposedHelpers.findAndHookMethod(Display.class, "getWidth", new RC_MethodHook() {
                    @Override
                    protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                        super.afterHookedMethod(param);
                        if (finalDevicesInfo.WScreen != null) {
                            param.setResult(Integer.valueOf(finalDevicesInfo.WScreen));
                        }
                    }
                });
            } catch (Exception e) {
                e.printStackTrace();
            }
            try {
                RposedHelpers.findAndHookMethod(Display.class, "getHeight", new RC_MethodHook() {
                    @Override
                    protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                        super.afterHookedMethod(param);
                        if (finalDevicesInfo.HScreen != null) {
                            param.setResult(Integer.valueOf(finalDevicesInfo.HScreen));
                        }
                    }
                });
            } catch (Exception e) {
                e.printStackTrace();
            }
            //Settings.Global.class;
            //USB调试模式

            try {
                Class Setting_Secure_Class = getMyClass(classLoader, Settings.Secure.class.getName());
                if (Setting_Secure_Class != null) {
                    RposedHelpers.findAndHookMethod(Setting_Secure_Class, "getInt",
                            ContentResolver.class,
                            String.class,
                            int.class, new RC_MethodHook() {
                                @Override
                                protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                                    super.afterHookedMethod(param);
                                    param.setResult(-1);
                                    Log.e(TAG, "初始化 Settings.Secure.getInt 被调用  " + param.getResult());
                                }
                            });
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            try {
                Class Setting_Global_Class = getMyClass(classLoader, Settings.Global.class.getName());
                if (Setting_Global_Class != null) {
                    RposedHelpers.findAndHookMethod(Setting_Global_Class, "getInt",
                            ContentResolver.class,
                            String.class,
                            int.class, new RC_MethodHook() {
                        @Override
                        protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                            super.afterHookedMethod(param);
                            param.setResult(-1);
                            Log.e(TAG, "初始化 Settings.Global.getInt 被调用  " + param.getResult());
                        }
                    });
                }
            } catch (Exception e) {
                e.printStackTrace();
            }

            //电量
//            BatteryManager batteryManager = (BatteryManager) getSystemService(BATTERY_SERVICE);
//            return batteryManager.getIntProperty(BatteryManager.BATTERY_PROPERTY_CAPACITY);
            try {
                Class BatteryManager_Class = getMyClass(classLoader, BatteryManager.class.getName());
                if (BatteryManager_Class != null) {
                    RposedHelpers.findAndHookMethod(BatteryManager_Class, "getIntProperty",
                            int.class,
                            new RC_MethodHook() {
                        @Override
                        protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                            super.afterHookedMethod(param);
                            //Log.e(TAG, "初始化 Settings.Global.getInt 被调用  " + param.getResult());
                            param.setResult(getRandom(99));
                            Log.e(TAG, "获取电量信息 " + param.getResult());
                        }
                    });

                }
                Log.e(TAG, "Hook执行完毕 ");
            } catch (Exception e) {
                e.printStackTrace();
            }

        } catch (Throwable e) {
            Log.e(TAG, "初始化设备信息异常  " + e.getMessage());
            e.printStackTrace();
        }