android代码保护永不闪退

最新推荐文章于 2023-09-25 10:13:37 发布
最新推荐文章于 2023-09-25 10:13:37 发布
阅读量2.3k 收藏 6
点赞数 4
分类专栏： Android 文章标签： 崩溃 保护 android hook
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_27512671/article/details/103323323
版权

在我们开发的过程中,再厉害的程序员也无法保证写的代码没有错误,而这里面最严重的错误,对于android开发来说,毫无疑问就是app闪退了.特别是在开发第三方SDK的时候,假设因为SDK里面报的问题,导致对方App崩溃了,这对SDK而言的打击是非常严重的,有的时候我们甚至希望SDK即使无法很好的工作,也不要引发对接方App的崩溃.

下面我就来介绍两种,可以根据代码判断,只会代码所在线程死掉,但不会引发崩溃的方法:

  1. hook Thread.UncaughtExceptionHandler 的方式
  2. 代理 Thread.UncaughtExceptionHandler 的方式

hook Thread.UncaughtExceptionHandler 的方式

第一种方式就是,我们在程序启动的时候,先使用Thread.getDefaultUncaughtExceptionHandler();拿到系统的错误处理Handler对象,再次之上,我们自己创建一个 Thread.UncaughtExceptionHandler 的继承类,包裹住系统的错误处理Handler对象之后,把我们自己创建的Thread.UncaughtExceptionHandler 传递回去.
系统的Thread.UncaughtExceptionHandler的实现类是com.android.internal.os.RuntimeInit$UncaughtHandler

hook代码如下:

    public void hook() {
        Thread.UncaughtExceptionHandler ueh = Thread.getDefaultUncaughtExceptionHandler();

        if (ueh == null) {
            mSystemUeh = null;
            mOtherUeh = null;
            Thread.setDefaultUncaughtExceptionHandler(CrashHookImpl2.this);
            return;
        }

        String androidUeh = "com.android.internal.os.RuntimeInit$UncaughtHandler";
        String selfUeh = getClass().getName();
        String currUeh = ueh.getClass().getName();

        //系统的
        if (androidUeh.equals(currUeh)) {
            mSystemUeh = ueh;
            mOtherUeh = null;
            Thread.setDefaultUncaughtExceptionHandler(CrashHookImpl2.this);
        } else if (selfUeh.equals(currUeh)) {
            //自己人 不处理
        } else {
            // bugly的 -> currUeh.contains("com.tencent.bugly.crashreport.crash")
            mSystemUeh = null;
            mOtherUeh = ueh;
            Thread.setDefaultUncaughtExceptionHandler(CrashHookImpl2.this);
        }
        return;
    }

其中,CrashHookImpl2是我们继承自Thread.UncaughtExceptionHandler 自己的实现类, 其中uncaughtException实现如下:

    @Override
    public void uncaughtException(Thread t, Throwable e) {
        //-----------自己的处理,拦截除0异常-------------------------------
        StackTraceElement[] elements = e.getStackTrace();
                for (int i = 0; i < elements.length; i++) {
                    if (e.getClass().getName().equals("java.lang.ArithmeticException")) {
                        return;
                    }
                }
        //-----------下面的系统的uncaughtException不走,既不会崩溃---------

        if (mOtherUeh != null) {
            mOtherUeh.uncaughtException(t, e);
        }
        if (mSystemUeh != null) {
            mSystemUeh.uncaughtException(t, e);
        }
    }

这时候, 我们可以在程序中写一个除以0 的异常,则是不会引发崩溃的,只会引发线程的停止:

        CrashHookImpl.getInstance().hook();
        CrashHookImpl.getInstance().addCutOffExceptionHandler(new CrashHook.CutOffExceptionHandler() {
            @Override
            public boolean onCutOffException(Thread t, Throwable e) {
                StackTraceElement[] elements = e.getStackTrace();
                for (int i = 0; i < elements.length; i++) {
                    if (e.getClass().getName().equals("java.lang.ArithmeticException")) {
                        return true;
                    }
                }
                return false;
            }
        });
        new Thread() {
            @Override
            public void run() {
                while (true) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(100 / 0 + "hook");
                    String nullp = null;
                    int a = nullp.length();
                }
            }
        }.start();

实现类全部代码:


import android.os.Build;
import android.os.Handler;
import android.os.HandlerThread;

import java.util.ArrayList;
import java.util.List;

public class CrashHookImpl2 implements Thread.UncaughtExceptionHandler, CrashHook {
    private static volatile CrashHookImpl2 instance = null;

    private Thread.UncaughtExceptionHandler mSystemUeh;
    private Thread.UncaughtExceptionHandler mOtherUeh;
    private List<CutOffExceptionHandler> exceptionHandlers;

    private CrashHookImpl2() {
        exceptionHandlers = new ArrayList<>();
    }

    @Override
    public void hook() {
        Thread.UncaughtExceptionHandler ueh = Thread.getDefaultUncaughtExceptionHandler();

        if (ueh == null) {
            mSystemUeh = null;
            mOtherUeh = null;
            Thread.setDefaultUncaughtExceptionHandler(CrashHookImpl2.this);
            return;
        }

        String androidUeh = "com.android.internal.os.RuntimeInit$UncaughtHandler";
        String selfUeh = getClass().getName();
        String currUeh = ueh.getClass().getName();

        //系统的
        if (androidUeh.equals(currUeh)) {
            mSystemUeh = ueh;
            mOtherUeh = null;
            Thread.setDefaultUncaughtExceptionHandler(CrashHookImpl2.this);
        } else if (selfUeh.equals(currUeh)) {
            //自己人 不处理
        } else {
            // bugly的 -> currUeh.contains("com.tencent.bugly.crashreport.crash")
            mSystemUeh = null;
            mOtherUeh = ueh;
            Thread.setDefaultUncaughtExceptionHandler(CrashHookImpl2.this);
        }
        return;
    }

    public static CrashHookImpl2 getInstance() {
        if (instance == null) {
            synchronized (CrashHookImpl2.class) {
                if (instance == null) {
                    instance = new CrashHookImpl2();
                }
            }
        }
        return instance;
    }

    @Override
    public void unHook() {
        if (mSystemUeh != null) {
            Thread.setDefaultUncaughtExceptionHandler(mSystemUeh);
            return;
        }
        if (mOtherUeh != null) {
            Thread.setDefaultUncaughtExceptionHandler(mSystemUeh);
            return;
        }
        Thread.setDefaultUncaughtExceptionHandler(null);
        return;
    }

    @Override
    public void addCutOffExceptionHandler(CrashHook.CutOffExceptionHandler cutOffExceptionHandler) {
        if (cutOffExceptionHandler == null) {
            return;
        }
        exceptionHandlers.add(cutOffExceptionHandler);
    }

    @Override
    public void removeCutOffExceptionHandler(CrashHook.CutOffExceptionHandler cutOffExceptionHandler) {
        if (cutOffExceptionHandler == null) {
            return;
        }
        exceptionHandlers.remove(cutOffExceptionHandler);
    }

    public void tryHook(final long time) {
        if (time < 0) {
            return;
        }
        final HandlerThread thread = new HandlerThread("hook_ch");
        thread.start();
        final Handler handler = new Handler(thread.getLooper());
        handler.post(new Runnable() {
            private int size = 0;

            @Override
            public void run() {
                if (size <= (time / 200)) {
                    size++;
                    hook();
                    handler.postDelayed(this, 200);
                } else {
                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2) {
                        thread.quitSafely();
                    } else {
                        thread.quit();
                    }
                }
            }
        });
        return;
    }


    @Override
    public void uncaughtException(Thread t, Throwable e) {
        for (int i = 0; i < exceptionHandlers.size(); i++) {
            boolean consumed = exceptionHandlers.get(i).onCutOffException(t, e);
            if (consumed) {
                return;
            }
        }

        if (mOtherUeh != null) {
            mOtherUeh.uncaughtException(t, e);
        }
        if (mSystemUeh != null) {
            mSystemUeh.uncaughtException(t, e);
        }
    }


}

代理 Thread.UncaughtExceptionHandler 的方式

实际上也是Hook默认的 Thread.UncaughtExceptionHandler , 但这种方式的好处是,我们自己无需创建实现Thread.UncaughtExceptionHandler接口的实现类,而只需要使用Proxy.newProxyInstance代理系统默认的Thread.UncaughtExceptionHandler就好了,这种方式比起上面一种来说,除了效果一致以外,好处可能就是可以避免一些代码的检查.

代理方式的hook代码:

    public void hook() {
        if (hooked) {
            return;
        }
        Thread.UncaughtExceptionHandler ueh = Thread.getDefaultUncaughtExceptionHandler();
        if (ueh == null) {
            return;
        }
        //代理逻辑
        class Px implements InvocationHandler {
            private Thread.UncaughtExceptionHandler handler;
            private Method uncaughtExceptionMethod;

            private Px(Thread.UncaughtExceptionHandler handler) {
                this.handler = handler;
                try {
                    uncaughtExceptionMethod = Thread.UncaughtExceptionHandler.class.getMethod("uncaughtException", Thread.class, Throwable.class);
                } catch (Throwable e) {
                }
            }

            @Override
            public Object invoke(Object proxy, Method method, Object[] args) {
                //先走自己的
                try {
                    if (uncaughtExceptionMethod != null && uncaughtExceptionMethod.equals(method)) {
                        if (args != null && args.length == 2) {
                            Thread thread = (Thread) args[0];
                            Throwable throwable = (Throwable) args[1];
                            for (int i = 0; i < exceptionHandlers.size(); i++) {
                                boolean cutoff = exceptionHandlers.get(i).onCutOffException(thread, throwable);
                                if (cutoff) {
                                    //截断
                                    return null;
                                }
                            }
                        }
                    }
                } catch (Throwable ignored) {
                }
                try {
                    //原来的
                    method.invoke(handler, args);
                } catch (Throwable ignored) {
                }
                return null;
            }
        }
        Thread.UncaughtExceptionHandler hookedUeh = (Thread.UncaughtExceptionHandler) Proxy.newProxyInstance(
                ueh.getClass().getClassLoader(),
                ueh.getClass().getInterfaces(),
                new Px(ueh));
        Thread.setDefaultUncaughtExceptionHandler(hookedUeh);
        hooked = true;
    }

本种方式的全部实现代码:


import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.List;

public class CrashHookImpl implements CrashHook {
    private List<CutOffExceptionHandler> exceptionHandlers;

    private static volatile CrashHookImpl instance = null;
    private boolean hooked = false;

    private CrashHookImpl() {
        exceptionHandlers = new ArrayList<>();
    }

    public static CrashHookImpl getInstance() {
        if (instance == null) {
            synchronized (CrashHookImpl.class) {
                if (instance == null) {
                    instance = new CrashHookImpl();
                }
            }
        }
        return instance;
    }

    @Override
    public void hook() {
        if (hooked) {
            return;
        }
        Thread.UncaughtExceptionHandler ueh = Thread.getDefaultUncaughtExceptionHandler();
        if (ueh == null) {
            return;
        }
        class Px implements InvocationHandler {
            private Thread.UncaughtExceptionHandler handler;
            private Method uncaughtExceptionMethod;

            private Px(Thread.UncaughtExceptionHandler handler) {
                this.handler = handler;
                try {
                    uncaughtExceptionMethod = Thread.UncaughtExceptionHandler.class.getMethod("uncaughtException", Thread.class, Throwable.class);
                } catch (Throwable e) {
                }
            }

            @Override
            public Object invoke(Object proxy, Method method, Object[] args) {
                try {
                    if (uncaughtExceptionMethod != null && uncaughtExceptionMethod.equals(method)) {
                        if (args != null && args.length == 2) {
                            Thread thread = (Thread) args[0];
                            Throwable throwable = (Throwable) args[1];
                            for (int i = 0; i < exceptionHandlers.size(); i++) {
                                boolean cutoff = exceptionHandlers.get(i).onCutOffException(thread, throwable);
                                if (cutoff) {
                                    //截断
                                    return null;
                                }
                            }
                        }
                    }
                } catch (Throwable ignored) {
                }
                try {
                    //原来的
                    method.invoke(handler, args);
                } catch (Throwable ignored) {
                }
                return null;
            }
        }
        Thread.UncaughtExceptionHandler hookedUeh = (Thread.UncaughtExceptionHandler) Proxy.newProxyInstance(
                ueh.getClass().getClassLoader(),
                ueh.getClass().getInterfaces(),
                new Px(ueh));
        Thread.setDefaultUncaughtExceptionHandler(hookedUeh);
        hooked = true;
    }

    @Override
    public void unHook() {
        if (!hooked) {
            return;
        }
        Thread.UncaughtExceptionHandler ueh = Thread.getDefaultUncaughtExceptionHandler();
        if (ueh == null) {
            return;
        }
        Thread.setDefaultUncaughtExceptionHandler(ueh);
        hooked = false;
    }

    @Override
    public void addCutOffExceptionHandler(CutOffExceptionHandler cutOffExceptionHandler) {
        if (cutOffExceptionHandler == null) {
            return;
        }
        exceptionHandlers.add(cutOffExceptionHandler);
    }

    @Override
    public void removeCutOffExceptionHandler(CutOffExceptionHandler cutOffExceptionHandler) {
        if (cutOffExceptionHandler == null) {
            return;
        }
        exceptionHandlers.remove(cutOffExceptionHandler);
    }
}

结语

对于崩溃,这两种方法只是避险的手段,而在我们的开发中,通过严谨的代码审查和测试,在上线之前解决问题,才是最好的选择.以上方法除了保护崩溃意外,还可以统计错误上报:
使用方法:

 CrashHookImpl.getInstance().hook();
        //保护所有的除零崩溃
        CrashHookImpl.getInstance().addCutOffExceptionHandler(new CrashHook.CutOffExceptionHandler() {
            @Override
            public boolean onCutOffException(Thread t, Throwable e) {
                if (e.getClass().getName().equals("java.lang.ArithmeticException")) {
                    //返回true,截断崩溃
                    return true;
                }
                return false;
            }
        });
        //统计上报
        CrashHookImpl.getInstance().addCutOffExceptionHandler(new CrashHook.CutOffExceptionHandler() {
            @Override
            public boolean onCutOffException(Thread t, Throwable e) {
                StackTraceElement[] elements = e.getStackTrace();
                for (int i = 0; i < elements.length; i++) {
                   String msg= elements[i].getClassName()+elements[i].getMethodName()+elements[i].getLineNumber();
                   //上报错误
                }
                //返回false 不截断
                return false;
            }
        });
痕迹丶
关注
专栏目录
Android应用的Crash闪退捕获
11-02
在Android应用开发中，"Crash闪退捕获"是一个至关重要的环节，它涉及到应用程序的稳定性和用户体验。当应用出现未处理的异常时，系统会强制关闭应用，这就是所谓的"闪退"。为了提高应用质量，开发者需要自定义异常...
android永不闪退版,Cockroach
weixin_35098081的博客
05-31 1036
Language[Chinese]很多人曲解了这个库的用意，现特声明如下当APP主线程抛出异常时就会导致APP crash，可能是由于view点击时抛出了异常等等，像这种异常我们更希望即使点击没反应也不要crash，用户顶多会认为是点了没反应，或者认为是本来就不可以点击，这时候就可以使用Cockroach，而且没有其他副作用，用户就跟没点一样，并且不影响其他逻辑。这样总比每次都crash要好很多，...
android 杜绝崩溃闪退处理
陈英有
05-08 2万+
当APP主线程抛出异常时就会导致APP crash，可能是由于view点击时抛出了异常等等，像这种异常我们更希望即使点击没反应也不要crash，用户顶多会认为是点了没反应，或者认为是本来就不可以点击，这时候就可以使用Cockroach，而且没有其他副作用，用户就跟没点一样，并且不影响其他逻辑。这样总比每次都crash要好很多，起码不会由于频繁crash导致用户卸载APP。
关于Android 启动连续闪退保护方案的思考
ASCE1885
08-06 407
背景应用启动时会执行一系列的初始化操作，例如读取热修复补丁包，读取 React Native 更新包，读取数据库，读取本地缓存文件，读取服务端数据等等，在其中某个环节如果...
Android应用线上闪退问题解决
最新发布
defdsdddev的博客
09-25 310
解决Android应用线上闪退问题需要仔细的监控、调试和分析。以下是一些解决Android线上闪退问题的工具和方法，希望对大家有所帮助。北京木奇移动技术有限公司，专业的软件外包开发公司，欢迎交流合作。
Android常见崩溃闪退问题的解决方案
哆啦安全
11-20 1万+
背景 Android开发过程中，APP崩溃是一类非常常见的问题，而且APP崩溃问题很多时候对APP安全还是致命性的。APP崩溃大部分是以闪退的形式出现。APP常见的崩溃原因有：NullPointerException 空指针、ClassCastException 类型转换异常、IndexOutOfBoundsException 下标越界异常、ActivityNotFoundException Activity未找到异常、IllegalStateException 非法状态异常、ArrayIndexOutO
android防止json闪退,Android Kotlin Json处理，避免null闪退
weixin_36319237的博客
05-28 439
一、 kotson 使用implementation 'com.github.salomonbrys.kotson:kotson:2.5.0'特点支持data 类的解析，不需要写默认值泛型解析上很方便，不再需要指出对应的TypeToken，fastjson对应的是(TypeReference)。这个真心是方便了读取 字段方便demopackage com.fangtao.jsonimport an...
安装android-86之后安装APP闪退的解决办法，亲测可用
05-14
解决了网络问题，就是安装软件后打开就闪退的问题了，这个解决办法亲测可用，大家可以试一下，就三四步，很简单。
Android高级混淆和代码保护技术
01-27
这是一篇关于Android代码保护的文章，旨在介绍代码混淆、防止逆向工程的各种高级技巧。大家都很忙，我也赶着回去继续开发我的新应用，因此话不多说，越干(gan, 一声)越好。 开始之前，值得一说的是，本文超过五千字...
Android实现多次闪退清除数据
09-02
本篇文章将探讨如何在Android上实现多次闪退后自动清除数据的机制。 首先，我们引入ACRA (Application Crash Report for Android)，这是一个开源项目，用于在应用崩溃时收集和报告错误信息。ACRA允许开发者自定义...
Android 7.0以上拍照闪退问题（权限被拒绝）
11-02
Android 7.0以上拍照闪退问题（权限被拒绝）解决android.os.FileUriExposedException: file:///storage/emulated/0/hphoto.png exposed beyond app through ClipData.Item.getUri()
Android app 闪退弹框 CrashUI当 Android app内发生exception
01-31
在Android应用开发中，"Android app 闪退弹框 CrashUI"是一个常见的问题，它涉及到应用程序异常处理和用户体验。当Android应用在运行时遇到未被捕获的异常（Exception），系统会默认终止应用并显示一个简单的错误...
Android 性能优化（一）：闪退、卡顿、耗电、APK
热门推荐
csdn_aiyang的博客
07-11 4万+
性能优化自2008年智能时代开始，Android操作系统开启一路高歌智能机发展之路。时至今日Android系统性能已经非常流畅了。到了不同层次的开发者手里，技术水平参差不齐，使得应用安装到配置极好的手机上依然存在体验差的现象。App性能优化是提升用户体验的永恒主题，也成为工程者最终的使命。性能优化从用户体验角度有四个性能优化方向。
Android未捕获异常不闪退,android监听器等无问题，不报错。但是运行时闪退
weixin_29487179的博客
05-28 172
com.example.administrator.demon4android.content.DialogInterfaceandroid.graphics.Colorandroid.location.GpsStatusandroid.support.v7.app.AppCompatActivityandroid.os.Bundleandroid.util.Logandroid.view.Vie...
Android隐私合规检测
wang_yong_hui_1234的博客
06-01 4106
随着国内渠道市场对APP规范越来越严格，在我们APP上线前需要做好隐私协议以及权限检查。由于项目中可能接入了第三方SDK，由于第三方SDK在初始化的时候可能会调用设备的隐私信息，因此检查合规非常的重要。一般情况下在用户使用APP的时候，只有选中了隐私协议之后，才能调取隐私信息。现在一些第三方SDK已经做了处理，比如：友盟SDK添加了预初始化，在预初始化的时候不会调取隐私信息。1，使用VirtualXposed在手机上装了一下虚拟系统，这里可以直接安装VirtualXposed.apk就可以 https://
Android总是闪退，怎么办？Android崩溃机制。
xian_yu_wan的博客
08-22 1931
闪退，程序退出这些都是开发中最常见的了。开发过程中，那还好说，遇到就解决被，主要还是应对上线问题。各大平台的捕获机制不少，用就完事了。但，我还是想知道Android崩溃机制。 所谓的闪退就是Android系统执行app的时候，发生不可以进行下去的步骤，追溯到最底层，就是堆栈内存的那点事咯。 这里推荐个简书的文章：https://www.jianshu.com/p/37b3c9f950dd 当然还有其他很优秀的文章，大家都搜索下。我这里也不贴出来了。 UncaughtExceptionHandler
Android全局异常捕获，不退出应用，让应用正常运行下去！
chuanao8829的博客
05-18 1174
Android全局异常捕获，不退出应用，让应用正常运行下去！ 当App发现异常后，如果程序没有处理，将交给虚拟机进行处理，通常会弹出一个对话框，然后退出应用。但大多数的异常可能对后续流程影响不大，比如分享功能出现。 一个问题，真的有必要关闭整个应用吗？屏蔽这个功能，对整体来说不会有太大的影...
win程序捕获系统异常防止突然闪退
weixin_44747201的博客
07-23 1225
开发中大型桌面程序，捕获系统异常防止程序突然崩溃
android 永不闪退,永不crash的Android
weixin_42509908的博客
05-31 749
Cockroach打不死的小强,永不crash的Android使用方式自定义Application继承自android的Application，并在Application中装载，越早初始化越好，可以在Aplication的onCreate中初始化，当然也可以根据需要在任意地方(不一定要在主线程)装载，在任意地方卸载。可以多次装载和卸载。例如：import android.app.Applicati...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

痕迹丶

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值