React Native release包全局错误处理——Android篇

87 阅读 0 评论 58 点赞

我是靠谱客的博主鲜艳啤酒，这篇文章主要介绍React Native release包全局错误处理——Android篇，现在分享给大家，希望可以做个参考。

当我们在开发React Native应用时，如果在调试状态下，获取错误的异常信息是非常简单的，JS异常会立即在真机上显示（或者打开调试模式在浏览器控制台中显示），原生层的java闪退异常则可以通过Android Studio的Logcat进行查看。

但是当我们将应用打包成apk包，并提交测试的时候，一旦出现异常或闪退都会比较棘手。如果复现步骤简单可能还好，我们可以尝试在开发环境下复现，可是一旦碰上小概率，且复现步骤不明确的bug就很难了，而且改bug的效率也会非常低。

这里就需要我们及时的将全局未捕获异常以文件的形式写入到手机本地存储中。接下来我将分两种情况介绍具体的处理方法：

1. JS异常

JS异常即RN层抛出的异常，如果异常不是很严重，往往会出现这种情况：APP未闪退，但是界面显示为白屏。

捕获React全局未捕获异常，需要借助componentDidCatch方法，我们可以先编写一个全局错误处理组件：

AppErrorHandler.js

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
/**
 * 全局JS异常捕获入口
 */
import React, { Component } from 'react';
import { saveJSExceptionsToStorage } from '@nativeModules';
import { LogUtil } from '@utils';

class AppErrorHandler extends Component {
  componentDidCatch(error, errorInfo) {
    // 全局未捕获JS异常处理，DEBUG模式输出日志，RELEASE模式存储日志到本地
    LogUtil("AppErrorHandler: ", error.stack);

    if (!__DEV__) {
      saveJSExceptionsToStorage(error.stack);
    }
  }

  render() {
    const { children } = this.props;

    return children;
  }
}

export default AppErrorHandler;

上面的saveJSExceptionsToStorage方法是我封装的将错误信息写入手机存储的原生方法，具体可以查看我的这篇博客。

error.stack是字符串形式的错误异常栈信息，这样获取到的异常信息比error.message要更加完整。

对__DEV__进行判断的作用是：只有在release模式中，才将JS异常写入本地，因为如果是调试状态，我们根本不需要存储异常信息。

然后就是在我们的根组件中：

App.js

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// ......

const App = () => {
  useEffect(() => {
    isMountedRef.current = true;

    return () => {
      isMountedRef.current = false;
    }
  });
      
  return (
    <AppErrorHandler>
      <Provider store={store}>
        <PersistGate loading={null} persistor={persistor}>
          <NavigationContainer ref={navigationRef}>
            <MainStack.Navigator initialRouteName='Splash' screenOptions={{ header: () => null }}>
              <MainStack.Screen name='Splash' component={Splash} />
              {AuthScreens()}
              {MainScreens()}
            </MainStack.Navigator>
          </NavigationContainer>
        </PersistGate>
      </Provider>
    </AppErrorHandler>
  );
};

export default App;

可以看到，我们把AppErrorHandler组件作为整个页面组件的根组件使用。这样在release包中抛出JS异常时，我们就能到

/storage/emulated/0/Android/data/${packageName}/file/jsExceptionLogs/log_yyyy_MM_dd_HH_mm_ss.txt中拿到异常信息。

注：建议将app中生成的日志文件保存在/storage/emulated/0/Android/data/${packageName}/file/路径下，这个路径的内容会在APP被卸载时清除。与他同级的还有一个目录/storage/emulated/0/Android/data/${packageName}/caches，这个目录中往往用来存放一些应用缓存的临时内容，会在用户手动清除应用缓存时一并删除。上述的两个路径应该是属于Android外部存储的私有路径，我们往这里写入文件是不需要动态申请外部存储（EXTERNAL_STORAGE）写入权限的。

2. 原生java异常

这类异常就比较严重了，一旦出现，APP会立即停止运行并闪退，造成极差的用户体验。为了捕获java中的全局未捕获异常，我们需要编写一个CrashHandler类并实现Thread.UncaughtExceptionHandler接口。代码比较简单，我就直接贴出整个类的实现吧：

CrashHandler.java

复制代码

package com.smarthome;

import android.content.Context;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.os.Build;
import android.os.Looper;
import android.util.Log;
import android.widget.Toast;

import androidx.annotation.NonNull;

import com.smarthome.utils.FileUtils;

import java.io.File;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.io.Writer;
import java.lang.reflect.Field;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;

/**
 * APP全局未捕获异常处理工具类
 * created by zhoujiahong 2020/02/28
 */
public class CrashHandler implements Thread.UncaughtExceptionHandler {
    private Context mContext;
    private static final String TAG = CrashHandler.class.getSimpleName();

private CrashHandler() { }

private static volatile CrashHandler instance;

static CrashHandler getInstance() {
        if (instance == null) {
            synchronized (CrashHandler.class) {
                if (instance == null) {
                    instance = new CrashHandler();
                }
            }
        }

return instance;
    }

private Map<String, String> crashInfos = new HashMap<>();  // 键值对的形式收集错误日志

/**
     * 初始化
     */
    void init() {
        mContext = MainApplication.getAppContext();
        // 设置CrashHandler为程序默认的处理器
        Thread.setDefaultUncaughtExceptionHandler(this);
    }

/**
     * 发生未捕获异常时的处理函数
     */
    @Override
    public void uncaughtException(@NonNull Thread thread, @NonNull Throwable throwable) {
        handleException(throwable);
    }

/**
     * 异常处理（收集包信息以及错误信息，导出本地文件或上传服务器）
     */
    private void handleException(Throwable throwable) {
        getPackageInfo();
        String crashMsg = saveCrashInfo(throwable);
        writeLogToStorage(crashMsg);
        uploadCrashToServer(crashMsg);
        remindUserOfCrash();
    }

/**
     * 获取包信息，并保存到crashInfos中
     */
    private void getPackageInfo() {
        PackageManager packageManager = mContext.getPackageManager();
        try {
            PackageInfo packageInfo = packageManager.getPackageInfo(mContext.getPackageName(), PackageManager.GET_CONFIGURATIONS);
            if (packageInfo != null) {
                String packageName = packageInfo.packageName;
                String versionName = packageInfo.versionName;
                String versionCode;
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
                    versionCode = String.valueOf(packageInfo.getLongVersionCode());
                } else {
                    versionCode = String.valueOf(packageInfo.versionCode);
                }

crashInfos.put("packageName", packageName);
                crashInfos.put("versionName", versionName);
                crashInfos.put("versionCode", versionCode);
            }
        } catch(PackageManager.NameNotFoundException e) {
            e.printStackTrace();
        }

Field[] fields = Build.class.getDeclaredFields();
        for (Field field : fields) {
            try {
                field.setAccessible(true);
                crashInfos.put(field.getName(), String.valueOf(field.get(null)));
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
    }

/**
     * 获取异常信息
     */
    private String saveCrashInfo(Throwable throwable) {
        StringBuilder sb = new StringBuilder();
        sb.append("Crash Log start: ==========================n");
        for (Map.Entry<String, String> entry : crashInfos.entrySet()) {
            String key = entry.getKey();
            String value = entry.getValue();
            sb.append(key).append(": ").append(value).append("n");
        }

Writer writer = new StringWriter();
        PrintWriter printWriter = new PrintWriter(writer);
        throwable.printStackTrace(printWriter);
        Throwable cause = throwable.getCause();
        // 回溯异常抛出链
        while (cause != null) {
            cause.printStackTrace(printWriter);
            cause = cause.getCause();
        }
        printWriter.close();
        String crashResult = writer.toString();
        sb.append("crashResult: ").append(crashResult);
        sb.append("end========================================n");
        return sb.toString();
    }

/**
     * 将闪退日志写入磁盘
     * @param crashMsg 闪退文本内容
     */
    private void writeLogToStorage(String crashMsg) {
        String externalFilePath = FileUtils.getExternalFileDir().getPath();
        String targetDir = externalFilePath + File.separator + "crashlogs";
        File log = new File(targetDir);
        if (log.exists() ||
                (!log.exists() && log.mkdir())) {
            StringBuilder targetFilePath = new StringBuilder();
            Date now = new Date();
            DateFormat dateFormat = new SimpleDateFormat("yyyy_MM_dd_HH_mm_ss", Locale.getDefault());
            targetFilePath.append(targetDir).append(File.separator).append("crashlog_").append(dateFormat.format(now)).append(".txt");
            File targetFile = new File(targetFilePath.toString());
            FileUtils.writeTextToFiles(targetFile, crashMsg);
        }
    }

/**
     * 上报服务端
     */
    private void uploadCrashToServer(String crashMsg) {
        Log.d(TAG, crashMsg);
    }

/**
     * 未捕获异常收集完成后，提示用户应用程序将退出
     */
    private void remindUserOfCrash() {
        new Thread(() -> {
            Looper.prepare();
            Toast.makeText(mContext, "抱歉，程序发生异常，即将退出o(╥﹏╥)o", Toast.LENGTH_LONG).show();
            Looper.loop();
        }).start();
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        android.os.Process.killProcess(android.os.Process.myPid());
        System.exit(1);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
package com.smarthome;

import android.content.Context;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.os.Build;
import android.os.Looper;
import android.util.Log;
import android.widget.Toast;

import androidx.annotation.NonNull;

import com.smarthome.utils.FileUtils;

import java.io.File;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.io.Writer;
import java.lang.reflect.Field;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;

/**
 * APP全局未捕获异常处理工具类
 * created by zhoujiahong 2020/02/28
 */
public class CrashHandler implements Thread.UncaughtExceptionHandler {
    private Context mContext;
    private static final String TAG = CrashHandler.class.getSimpleName();

    private CrashHandler() { }

    private static volatile CrashHandler instance;

    static CrashHandler getInstance() {
        if (instance == null) {
            synchronized (CrashHandler.class) {
                if (instance == null) {
                    instance = new CrashHandler();
                }
            }
        }

        return instance;
    }

    private Map<String, String> crashInfos = new HashMap<>();  // 键值对的形式收集错误日志

    /**
     * 初始化
     */
    void init() {
        mContext = MainApplication.getAppContext();
        // 设置CrashHandler为程序默认的处理器
        Thread.setDefaultUncaughtExceptionHandler(this);
    }

    /**
     * 发生未捕获异常时的处理函数
     */
    @Override
    public void uncaughtException(@NonNull Thread thread, @NonNull Throwable throwable) {
        handleException(throwable);
    }

    /**
     * 异常处理（收集包信息以及错误信息，导出本地文件或上传服务器）
     */
    private void handleException(Throwable throwable) {
        getPackageInfo();
        String crashMsg = saveCrashInfo(throwable);
        writeLogToStorage(crashMsg);
        uploadCrashToServer(crashMsg);
        remindUserOfCrash();
    }

    /**
     * 获取包信息，并保存到crashInfos中
     */
    private void getPackageInfo() {
        PackageManager packageManager = mContext.getPackageManager();
        try {
            PackageInfo packageInfo = packageManager.getPackageInfo(mContext.getPackageName(), PackageManager.GET_CONFIGURATIONS);
            if (packageInfo != null) {
                String packageName = packageInfo.packageName;
                String versionName = packageInfo.versionName;
                String versionCode;
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
                    versionCode = String.valueOf(packageInfo.getLongVersionCode());
                } else {
                    versionCode = String.valueOf(packageInfo.versionCode);
                }

                crashInfos.put("packageName", packageName);
                crashInfos.put("versionName", versionName);
                crashInfos.put("versionCode", versionCode);
            }
        } catch(PackageManager.NameNotFoundException e) {
            e.printStackTrace();
        }

        Field[] fields = Build.class.getDeclaredFields();
        for (Field field : fields) {
            try {
                field.setAccessible(true);
                crashInfos.put(field.getName(), String.valueOf(field.get(null)));
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 获取异常信息
     */
    private String saveCrashInfo(Throwable throwable) {
        StringBuilder sb = new StringBuilder();
        sb.append("Crash Log start: ==========================n");
        for (Map.Entry<String, String> entry : crashInfos.entrySet()) {
            String key = entry.getKey();
            String value = entry.getValue();
            sb.append(key).append(": ").append(value).append("n");
        }

        Writer writer = new StringWriter();
        PrintWriter printWriter = new PrintWriter(writer);
        throwable.printStackTrace(printWriter);
        Throwable cause = throwable.getCause();
        // 回溯异常抛出链
        while (cause != null) {
            cause.printStackTrace(printWriter);
            cause = cause.getCause();
        }
        printWriter.close();
        String crashResult = writer.toString();
        sb.append("crashResult: ").append(crashResult);
        sb.append("end========================================n");
        return sb.toString();
    }

    /**
     * 将闪退日志写入磁盘
     * @param crashMsg 闪退文本内容
     */
    private void writeLogToStorage(String crashMsg) {
        String externalFilePath = FileUtils.getExternalFileDir().getPath();
        String targetDir = externalFilePath + File.separator + "crashlogs";
        File log = new File(targetDir);
        if (log.exists() ||
                (!log.exists() && log.mkdir())) {
            StringBuilder targetFilePath = new StringBuilder();
            Date now = new Date();
            DateFormat dateFormat = new SimpleDateFormat("yyyy_MM_dd_HH_mm_ss", Locale.getDefault());
            targetFilePath.append(targetDir).append(File.separator).append("crashlog_").append(dateFormat.format(now)).append(".txt");
            File targetFile = new File(targetFilePath.toString());
            FileUtils.writeTextToFiles(targetFile, crashMsg);
        }
    }

    /**
     * 上报服务端
     */
    private void uploadCrashToServer(String crashMsg) {
        Log.d(TAG, crashMsg);
    }

    /**
     * 未捕获异常收集完成后，提示用户应用程序将退出
     */
    private void remindUserOfCrash() {
        new Thread(() -> {
            Looper.prepare();
            Toast.makeText(mContext, "抱歉，程序发生异常，即将退出o(╥﹏╥)o", Toast.LENGTH_LONG).show();
            Looper.loop();
        }).start();
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        android.os.Process.killProcess(android.os.Process.myPid());
        System.exit(1);
    }
}