android os模块中static final 修饰的字段修改

最新推荐文章于 2022-01-04 22:25:20 发布
最新推荐文章于 2022-01-04 22:25:20 发布
阅读量564 收藏
点赞数
文章标签： 移动开发 java
原文链接：http://blog.51cto.com/haidragon/2407216
版权

xp：
XposedHelpers.setStaticObjectField(classBuild, "SERIAL","serial")

//XposedHelpers.setStaticObjectField(classBuild, "SERIAL",
//                    SharedPref.getXValue("serial"))

手动修改

 // 把一个字符串的第一个字母大写、效率是最高的、
    private static String getMethodName(String fildeName) throws Exception{
        byte[] items = fildeName.getBytes();
        items[0] = (byte) ((char) items[0] - 'a' + 'A');
        return new String(items);
    }
public void AndroidSerial(XC_LoadPackage.LoadPackageParam loadPkgParam){
        try {
//-------------------------------------2019 - 6 - 10 haidragon修改   ------------------------------------
//            Class<?> classBuild = XposedHelpers.findClass("android.os.Build",
//                    loadPkgParam.classLoader);
            final Class<?> classBuild = loadPkgParam.classLoader.loadClass("android.os.Build");
            XposedHelpers.findAndHookMethod(classBuild, "getString",String.class, new XC_MethodHook() {
                @Override
                protected void afterHookedMethod(MethodHookParam param) throws Throwable {
                    super.afterHookedMethod(param);
                    //打印调用堆栈
                    new Exception("trak").printStackTrace();
                    Log.i(TAG,"findAndHookMethod "+"返回值："+param.getResult()+"参数："+param.args[0]);
                    //param.setResult(false);
                }
            });
//            XposedHelpers.setStaticObjectField(classBuild, "SERIAL",
//                    SharedPref.getXValue("serial")); // 串口序列号
            Class<?> Class_android_os_Build=Class.forName("android.os.Build");
            Field nameField =Class_android_os_Build.getDeclaredField("SERIAL");
            nameField.setAccessible(true);
//            Field modifiers = Field.class.getDeclaredField("modifiers");
//            modifiers.setAccessible(true);
//            modifiers.setInt(nameField,nameField.getModifiers() & ~Modifier.FINAL);
            //nameField.set(null,SharedPref.getXValue("serial"));
           nameField.set(null,"修改成功！！！"); nameField.set(Class_android_os_Build.getConstructor().newInstance(),"haidragon");
//            modifiers.setAccessible(true);
//            modifiers.setInt(nameField, nameField.getModifiers() & ~Modifier.FINAL);
//            nameField.set(classBuild.getConstructor().newInstance(),SharedPref.getXValue("serial"));
            Log.i(TAG,"test public static final String SERIAL: "+nameField.get(classBuild.getConstructor().newInstance()));
//            Log.i(TAG,"test public static final String SERIAL: "+nameField.get());
//            modifiers.setInt(nameField, nameField.getModifiers() & ~Modifier.FINAL);

            //test public static final String SERIAL = getString("no.such.thing");
            Log.i(TAG,"test public static final String SERIAL = getString");

            Log.i(TAG,"test public static final String SERIAL = getString"+"类 ："+Class_android_os_Build.getName());
            Method method_getString=Class_android_os_Build.getDeclaredMethod("getString",String.class);
            Log.i(TAG,"test public static final String SERIAL = getString"+"方法 ："+method_getString.getName());
            method_getString.setAccessible(true);//设置可访问
            String retn= (String)method_getString.invoke(Class_android_os_Build.getConstructor().newInstance(),"ro.build.user");
            Log.i(TAG,"test public static final String SERIAL = getString ro.build.user "+"返回值："+retn);
            String str_no_such_thing= (String)method_getString.invoke(Class_android_os_Build.getConstructor().newInstance(),"no.such.thing");
            Log.i(TAG,"test public static final String SERIAL = getString no.such.thing "+"返回值："+str_no_such_thing);
            String str_ro_build_host= (String)method_getString.invoke(Class_android_os_Build.getConstructor().newInstance(),"ro.build.host");
            Log.i(TAG,"test public static final String SERIAL = getString no.such.thing "+"返回值："+str_ro_build_host);
            //遍历内部类
            for (final Class class1 : classBuild.getDeclaredClasses()){
                //判断类是不是枚举类
                if(class1.isEnum()){
                    //获取内部内的类名，在这里其实就是获取枚举类
                    String simpleName = class1.getSimpleName();
                    Log.i(TAG,"枚举类名："+simpleName);
                    //反射获取枚举类
                    Class<Enum> clazz = (Class<Enum>)Class.forName("com.zr.entity.Constant$"+simpleName);
                    //获取所有枚举实例
                    Enum[] enumConstants = clazz.getEnumConstants();
                    //根据方法名获取方法
                    Method getCode = clazz.getMethod("getDesc");
                    for (Enum enum1 : enumConstants) {
                        //得到枚举实例名
                        String name2 = enum1.name();
                        //执行枚举方法获得枚举实例对应的值
                        Object invoke = getCode.invoke(enum1);
                        System.out.println(name2+":"+invoke.toString());
                        Log.i(TAG,"获得枚举实例对应的值："+name2+":"+invoke.toString());
                    }
                    //其它类
                }else {
                    Log.i(TAG,"内部内的类名："+class1.getSimpleName());
                    for (final  Method method:class1.getDeclaredMethods()){
                        Log.i(TAG,"内部内的类中的方法名："+method.getName());
                    }
                }
            }
            //遍历所有构造函数
            for (final Constructor<?> constructor : classBuild.getConstructors()) {
                Log.i(TAG,"构造函数："+constructor.getName());
            }
            //遍历所有的方法
            for (final  Method method:classBuild.getDeclaredMethods()) {
                Log.i(TAG, "类中的方法名：" + method.getName());
                method.setAccessible(true); //设置字段访问属性
                if (!Modifier.isAbstract(method.getModifiers()) && !Modifier.isNative(method.getModifiers()) && !Modifier.isInterface(method.getModifiers())){
                    XposedBridge.hookMethod(method, new XC_MethodHook() {
                        //跳过编译时的lint检查  会存在适配问题
                        //被hook的函数前先执行
                        @SuppressLint("NewApi")
                        @Override
                        protected void beforeHookedMethod(MethodHookParam param) throws Throwable {
                            super.beforeHookedMethod(param);
                            if (param.args != null)
                                //if(param.args.length>0)
                                Log.i(TAG, "beforeHookedMethod 方法名：" + method.getName() + "返回值：" + param.getResult() + "参数：" + param.args[0]);
                            else
                                Log.i(TAG, "beforeHookedMethod 方法名：" + method.getName() + "返回值：" + param.getResult() + "参数：NULL");
                        }
                        //被hook的函数前先执行
//                    @SuppressLint("NewApi")
//                    @Override
//                    protected void afterHookedMethod(MethodHookParam param) throws Throwable {
//                        super.afterHookedMethod(param);
//                        if(param.args!=null)
//                            //if(param.args.length>0)
//                            Log.i(TAG,"afterHookedMethod 方法名："+method.getName()+"返回值："+param.getResult()+"参数："+param.args[0]);
//                        else
//                            Log.i(TAG,"afterHookedMethod 方法名："+method.getName()+"返回值："+param.getResult()+"参数：null");
//                    }
                    });
                }
            }
            //遍历所有属性
            for (final Field field:classBuild.getDeclaredFields()){
             //   Log.i(TAG,"test public static final String SERIAL = getString");
                Log.i(TAG,"类中的属性名："+field.getName()+"类型："+field.getGenericType().toString() +"类型修改符 ："+field.getModifiers());
              //  Log.i(TAG,"test public static final String SERIAL = getString");
            }
            for (final Field field : classBuild.getDeclaredFields()) {// --for() begin
                Log.i(TAG,"类中的属性名："+field.getName()+"类型："+field.getGenericType().toString() +"类型修改符 ："+field.getModifiers());
                // 如果类型是String
                if (field.getGenericType().toString().equals(
                        "class java.lang.String")) { // 如果type是类类型，则前面包含"class "，后面跟类名
                    // 拿到该属性的gettet方法
                    /**
                     * 这里需要说明一下：他是根据拼凑的字符来找你写的getter方法的
                     * 在Boolean值的时候是isXXX（默认使用ide生成getter的都是isXXX）
                     * 如果出现NoSuchMethod异常 就说明它找不到那个gettet方法 需要做个规范
                     */
                    Method m = (Method) classBuild.getClass().getMethod(
                            "get" + getMethodName(field.getName()));

                    String val = (String) m.invoke(classBuild);// 调用getter方法获取属性值
                    if (val != null) {
                        System.out.println("String type:" + val);
                        Log.i(TAG,"类中的属性名："+field.getName()+"类型："+field.getGenericType().toString() +"类型修改符 ："+field.getModifiers()+" val:"+val);
                    }

                }

                // 如果类型是Integer
                if (field.getGenericType().toString().equals(
                        "class java.lang.Integer")) {
                    Method m = (Method) classBuild.getClass().getMethod(
                            "get" + getMethodName(field.getName()));
                    Integer val = (Integer) m.invoke(classBuild);
                    if (val != null) {
                        System.out.println("Integer type:" + val);
                        Log.i(TAG,"类中的属性名："+field.getName()+"类型："+field.getGenericType().toString() +"类型修改符 ："+field.getModifiers()+" val:"+val);
                    }

                }

                // 如果类型是Double
                if (field.getGenericType().toString().equals(
                        "class java.lang.Double")) {
                    Method m = (Method) classBuild.getClass().getMethod(
                            "get" + getMethodName(field.getName()));
                    Double val = (Double) m.invoke(classBuild);
                    if (val != null) {
                        System.out.println("Double type:" + val);
                        Log.i(TAG,"类中的属性名："+field.getName()+"类型："+field.getGenericType().toString() +"类型修改符 ："+field.getModifiers()+" val:"+val);
                    }

                }

                // 如果类型是Boolean 是封装类
                if (field.getGenericType().toString().equals(
                        "class java.lang.Boolean")) {
                    Method m = (Method) classBuild.getClass().getMethod(
                            field.getName());
                    Boolean val = (Boolean) m.invoke(classBuild);
                    if (val != null) {
                        System.out.println("Boolean type:" + val);
                        Log.i(TAG,"类中的属性名："+field.getName()+"类型："+field.getGenericType().toString() +"类型修改符 ："+field.getModifiers()+" val:"+val);
                    }

                }

                // 如果类型是boolean 基本数据类型不一样 这里有点说名如果定义名是 isXXX的 那就全都是isXXX的
                // 反射找不到getter的具体名
                if (field.getGenericType().toString().equals("boolean")) {
                    Method m = (Method) classBuild.getClass().getMethod(
                            field.getName());
                    Boolean val = (Boolean) m.invoke(classBuild);
                    if (val != null) {
                        System.out.println("boolean type:" + val);
                        Log.i(TAG,"类中的属性名："+field.getName()+"类型："+field.getGenericType().toString() +"类型修改符 ："+field.getModifiers()+" val:"+val);
                    }

                }
                // 如果类型是Date
                if (field.getGenericType().toString().equals(
                        "class java.util.Date")) {
                    Method m = (Method) classBuild.getClass().getMethod(
                            "get" + getMethodName(field.getName()));
                    Date val = (Date) m.invoke(classBuild);
                    if (val != null) {
                        System.out.println("Date type:" + val);
                        Log.i(TAG,"类中的属性名："+field.getName()+"类型："+field.getGenericType().toString() +"类型修改符 ："+field.getModifiers()+" val:"+val);
                    }

                }
                // 如果类型是Short
                if (field.getGenericType().toString().equals(
                        "class java.lang.Short")) {
                    Method m = (Method) classBuild.getClass().getMethod(
                            "get" + getMethodName(field.getName()));
                    Short val = (Short) m.invoke(classBuild);
                    if (val != null) {
                        System.out.println("Short type:" + val);
                        Log.i(TAG,"类中的属性名："+field.getName()+"类型："+field.getGenericType().toString() +"类型修改符 ："+field.getModifiers()+" val:"+val);
                    }

                }
                // 其他的类型

              }//for() --end

//-------------------------------------2019 - 6 - 10 haidragon修改  ------------------------------------

            Class<?> classSysProp = Class
                    .forName("android.os.SystemProperties");
            XposedHelpers.findAndHookMethod(classSysProp, "get", String.class,
                    new XC_MethodHook() {

                        @Override
                        protected void afterHookedMethod(MethodHookParam param)
                                throws Throwable {
                            // TODO Auto-generated method stub
                            super.afterHookedMethod(param);
                            String serialno = (String) param.args[0];

                            if (serialno.equals("gsm.version.baseband")
                                    || serialno.equals("no message")
                            ) {
                                param.setResult(SharedPref.getXValue("getBaseband"));
                            }
                        }

                    });

            XposedHelpers.findAndHookMethod(classSysProp, "get", String.class,
                    String.class, new XC_MethodHook() {

                        @Override
                        protected void afterHookedMethod(MethodHookParam param)
                                throws Throwable {
                            // TODO Auto-generated method stub
                            super.afterHookedMethod(param);

                            String serialno = (String) param.args[0];
                            if (serialno.equals("gsm.version.baseband")
                                    || serialno.equals("no message")
                            ) {
                                param.setResult(SharedPref.getXValue("getBaseband"));
                            }
                        }

                    });
            return;
        } catch (Exception ex) {
            XposedBridge.log(" AndroidSerial 错误: " + ex.getMessage());
        }
    }

android os模块中static final 修饰的字段修改
java和android有点不同：
https://www.cnblogs.com/noKing/p/9038234.html
https://github.com/GoldArowana/K-Object/tree/master/src/test/java/reflect/field

转载于:https://blog.51cto.com/haidragon/2407216

weixin_33806509
关注
在Android中使用反射获取并修改private static final成员
MasonChen的专栏
12-12 4332
import android.app.Instrumentation; import android.test.InstrumentationTestCase; import android.util.Log; import java.lang.reflect.Field; import java.lang.reflect.Modifier; /** * Created by mark_ch
java 反射 static final_反射修改 static final 变量
weixin_39789525的博客
02-16 805
一、测试结论static final 修饰的基本类型和String类型不能通过反射修改;二、测试案例@Testpublic void test01() throws Exception {setFinalStatic(Constant.class.getDeclaredField("i1"), 11);System.out.println(Constant.i1);setFinalStatic(C...
Final修饰的String真的不能修改吗
Pausch的博客
01-24 655
通过反射可以修改 public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException { final String rs = "aaaaaa"; Field value = rs.getClass().getDeclaredField("value"); value.setAccessible(true); char[] item
反射的更改 更改 static final 静态常量的值 。 这样就能动态的更改 决定spring 用那一套实现...
weixin_30894389的博客
05-18 331
public class Bean {public static final String dbtype=new String();}public static void changFinalProperty(Class clazz ,Object newvalue){try {Object o = clazz.n...
反射修改 static final 修饰的基本类型常量
meishem52的博客
01-04 495
测试发现，反射可以修改产量内容，但是代码里引用常量的地方不会发生变化，因为编译器编译代码时，会把常量直接优化写死。 假如我们写的代码： static final int max = 100； if（x > max）{.......} 经过编译器编译后实际运行代码： if（x > 100）{.......} ...
final 值可以修改吗_final,接口
weixin_34677379的博客
11-30 2467
【1】final修饰变量：public class Test { public static void main(String[] args) { //1...... final int A=10;//基本数据类型被final修饰，它的数值不可以被修改。 // A=20; System.out.println(A); ...
使用static + final修饰的字段的显示赋值，到底是在哪个阶段进行的赋值？
qq_42778327的博客
08-18 1030
测试代码 public static int a = 1;//在初始化阶段<clinit>()中赋值 public static final int INT_CONSTANT = 10;//在链接阶段的准备环节赋值 public static final Integer INT_CONSTANT1 = Integer.valueOf(100);//在初始化阶段<clinit>()中赋值 public static Integer INT_CONS
java 反射 static final_Java反射修改static和final相关变量的思考
weixin_42549117的博客
02-13 997
问题起初反射修改String的final变量，按理应该能够修改的，但是发现修改不了？但是如果把String赋值形式改为new String("xxx");，则可以，又是为什么？为什么反射修改 final String str = "" 变量修改不了，而 final String str = new String("xxx") 形式可以修改？为什么反射修改非static的final变量不消去fina...
奇技淫巧：Java中的final字段真的不能修改么？(怎样修改final字段)
adu003的博客
02-18 8615
怎样修改Java中的final字段？ 先说答案：通过反射是可以修改final字段的！ ps:但是修改后的数据能不能生效(正确访问到修改后的数据)就得看情况了，不同的数据类型、不同的数据初始化方式、不同的访问方式都可能导致修改后访问到的数据还是原数据。下边通过几个案例一一验证: final关键字简介 在Java中，final关键字可以用来修饰类、方法和数据（包括成员变量和局部变量）。 1.final数据 对于一个final数据...
三个修饰符(abstract、static、final)
12-21
Java中有三个重要的修饰符：`abstract`、`static`和`final`，它们分别用于不同的目的。 1. `abstract`修饰符： - `abstract`修饰的类被称为抽象类。抽象类在编译后会生成一个独立的`.class`文件，但不能直接实例化...
vendor_mediatek_hardware_telephony-ext
02-21
联发科技电话扩展重新实现 这些最初由phhusson直接放置在frameworks/opt/telephony内部。 由于Android 10引入了用于供应商电话扩展的新注入框架，因此我们可以将其放在此处，以将我们的代码与框架分离。 这是MTK的IRadioIndication和IRadioResponse接口的部分重新实现，足以使传入呼叫正常工作。 暂时不支持IMS（VoLTE）。 非常感谢phhusson和整个GSI社区弄清楚了这一点。 要使用此功能，您需要将此存储库克隆到vendor/mediatek/hardware/telephony-ext ，并将HIDL定义克隆到vendor/mediatek/hardware/interfaces 。 之后，您需要将vendor/mediatek/hardware/telephony-ext/overlay.mk包含到device.mk
Android 修改 final 类型的 field
ReadyShowShow的博客
11-20 1909
这是一个比较特殊的知识点，需要从HotSpot与Dalvik的区别说起。 问题起因 相信大家在继承RecycleView时，对ViewHolder中的itemView都有重写的欲望。这个itemView是final类型的，不容许被修改，极大的限制了开发的自由。 那首先想到的就是利用反射来修改该字段。可是运行会报错。 创建一个通用方法进行反射修改属性值,如下： public static void ...
Build.VERSION.SDK_INT
zw1143498524的专栏
10-28 1459
尽管Android向下兼容不好，但是一个程序还是可以在多个平台上跑的。向下兼容不好，接口改变，新的平台上不能用旧的API，旧的平台更不可能用新的API，不等于一个平台需要一个APK。可以在高SDK上开发，并在程序中作版本判断，低版本运行环境使用旧的API。           例如要开发一个显示通话记录的程序，需要兼容1.6~2.2，我们知道不同的平台SDK level不同，1.5是3,1.
android build类分析 hook静态字段
lonelykin的专栏
11-02 7727
缘由： 使用xposed hook build类下 DEVICE MODEL VERSION MANUFACTURER等静态字段XposedHelpers.setStaticObjectField(android.os.Build.class, "MODEL", "null");hook 失败！ <参考：http://blog.csdn.net/ccpat/article/details/44
Android UUID生成（IMEI、设备序列号、MAC地址）
dibe49481448的博客
05-15 997
根据手机设备的IMEI、设备序列号、MAC地址经过MD5加密，得到手机专有的序号； import android.content.Context; import android.net.wifi.WifiInfo; import android.net.wifi.WifiManager; import android.os.Build; import android.tel...
Android 网络框架之Retrofit源码解析
鸿蒙开发知识记录
10-21 943
在使用了Retrofit之后，你是否会有这样的疑问： 1、为什么有OkHttp这么强大的网络框架了，Retrofit还能脱颖而出？ 2、Retrofit是怎么适配第三方框架的？ 3、Retrofit用了哪些设计模式？ 4、Retrofit为什么好用？ 下面我们就来探索Retrofit的真面目吧！ 本文基于以下Java版本解析： // retrofit implementation 'com.squareup.retrofit2:retrofit:2.5.0' implementation 'com.s.
Android进阶：七、Retrofit2-0原理解析之最简流程，面试一路绿灯Offer拿到手软
m0_64319496的博客
11-17 273
很明显这个方法是在传一些需要的参数，我们简单的跟踪一下： 首先看看Builder()的源码： public Builder() { this(Platform.get()); } 这句代码很简单就是调用了自己的另一个构造函数： Builder(Platform platform) { this.platform = platform; } 这个构造函数也很简单，就是一个赋值，我们把之前的Platform.get()点开，看看里面做在什么： private static final Platform PLAT
深入浅出 - Android系统移植与平台开发（十二）- Android JNI机制
热门推荐
mr_raptor的专栏
06-11 1万+
第五章、JNI机制4.1 JNI概述 由前面基础知识可知，Android的应用层由Java语言编写，Framework框架层则是由Java代码与C/C++语言实现，之所以由两种不同的语言组合开发框架层，是因为Java代码是与硬件环境彻底“隔离”的跨平台语言，Java代码无法直接操作硬件。比如：Android系统支持大量传感器，Java运行在虚拟机中，无法直接得到传感器数据，而Android系统基于
Android Studio3.0开发JNI流程------JNI函数
美好的一天从”心“开始
11-29 2242
JNI函数 本章为JNI函数提供参考信息。其中列出了全部JNI函数，同时也给出了JNI函数表的准确布局。注意：“必须”一词用于约束JNI编程人员。例如，当说明某个JNI函数必须接收非空对象时，就应确保不要向该JNI函数传递NULL值。这时，JNI实现将无需在该JNI函数中执行NULL指针检查。 接口函数表 每个函数均可通过JNIEnv参数以固定偏移量进行访问。JNIEnv的类型是一个指针，指
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值