Android全局异常捕捉

在Android开发中有些异常是开发和测试中不可遇见的,会在上线后给用户使用的时候才产生.有写是小Exception和一些可能会让App奔溃的问题,这样问题出来App莫名奇妙的就卡住死掉了.用户体验就不好.在App崩溃之前主动讲App杀死,然后给用户一些友好的提示.我们还需要把令App奔溃的Excepion记入在文件上.等到下次app开启的时候在推送到service.以便我们后期修复Bug.

下面是自己写的一个简单的全局异常捕捉器(我使用kotlin写的)

 

package com.example.dome.utils

import android.content.pm.PackageManager
import android.os.Build
import android.os.Environment
import android.os.Looper
import com.example.dome.MyApplition
import java.io.*
import java.text.SimpleDateFormat
import java.util.*


/**
 * Created by qikais on 2017/7/4.  单利使用object修饰
 */
object CrashHandler : Thread.UncaughtExceptionHandler {

    val TAG = "CrashHandler"
    private var infos = HashMap<String, String>()   //用来存储设备信息和异常信息
    private val formatter = SimpleDateFormat("yyyy-MM-dd-HH-mm-ss")
    private var mDefaultHandler: Thread.UncaughtExceptionHandler? = null //系统默认的UncaughtException处理类

    fun init() {
        mDefaultHandler = Thread.getDefaultUncaughtExceptionHandler()
        //设置该CrashHandler为程序的默认处理器
        Thread.setDefaultUncaughtExceptionHandler(this) //设置该CrashHandler为程序的默认处理器
    }


    override fun uncaughtException(t: Thread?, e: Throwable?) {
        if (!handleException(e)&& mDefaultHandler!=null){
            mDefaultHandler!!.uncaughtException(t,e)
        }else{
            try {
                Thread.sleep(3000)
            } catch (e: InterruptedException) {
                LogUtils.e(TAG, "error : ")
            }
            //退出程序
            android.os.Process.killProcess(android.os.Process.myPid())
            System.exit(1)
        }
    }

    /** 自定义错误处理,收集错误信息 发送错误报告等操作均在此完成.处理了就返回true*/
    private fun handleException(e: Throwable?):Boolean{
        if (e==null){
            return false
        }
        Thread({
            Looper.prepare()
            ToastUtils.show("很抱歉,程序出现异常,即将退出.")
            Looper.loop()
        }).start()
        collectDeviceInfo()
        saveCrashInfo2File(e)
        return true
    }

    /**收集异常信息*/
    private fun collectDeviceInfo(){
        try {
            val packageManager = MyApplition.appcontext.packageManager
            val packageInfo = packageManager.getPackageInfo(MyApplition.appcontext.packageName, PackageManager.GET_ACTIVITIES)
            if (packageInfo!=null){
                var versionName : String =packageInfo.packageName?:"null"
                println(versionName)
                var versionCode :String= "${packageInfo.versionCode}"
                infos.put("versionName",versionName)
                infos.put("versionCode",versionCode)
            }
        }catch (e:PackageManager.NameNotFoundException){
            LogUtils.e(TAG,"an error occured when collect package info")
        }
        val declaredFields = Build::class.java.declaredFields
        for (field in declaredFields){
            try {
                field.isAccessible=true
                infos.put(field.name,field.get(null).toString())
                LogUtils.d(TAG,"${field.name}:${field.get(null)}")
            } catch(e: Exception) {
                LogUtils.e(TAG,"an error occured when collect crash info")
            }
        }
    }

    /**讲错误信息保存到文件里*/
    private fun saveCrashInfo2File(e:Throwable) : String? {
        val stringBuffer = StringBuffer()
        for ((key, value) in infos) {
            stringBuffer.append(key + "=" + value + "\n")
        }
        val stringWriter:Writer = StringWriter()
        val printWriter :PrintWriter = PrintWriter(stringWriter)
        e.printStackTrace(printWriter)
        var cause :Throwable? = e.cause
        while (cause!=null){
            cause.printStackTrace(printWriter)
            cause = cause.cause
        }
        printWriter.close()
        val result  = stringWriter.toString()
        stringBuffer.append(result)
        try {
            var timestamp : Long=System.currentTimeMillis()
            val time = formatter.format(Date())
            val fileName = "crash-$time-$timestamp.log"
            if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)){
                var path : String ="/sdcard/crash/"
                var dir : File=File(path)
                if(!dir.exists()){
                    dir.mkdirs()
                }
                val fos : FileOutputStream = FileOutputStream(path + fileName)
                fos.write(stringBuffer.toString().toByteArray())
                fos.close()
            }
            return fileName
        }catch (e :Exception){
            LogUtils.e(TAG,"an error occured while writing file...")
        }
        return null
    }
}

相当于注释

 

 

比较少.其实实现思路就是实现UncaughtExceptionHandler,收集异常信息讲,异常信息写到文件中

 

对应的kotiln引入项目方法 看我 http://blog.csdn.net/shenqikai0319/article/details/73250912 博客

具体kotlin语法我也给大家分享一个比较好的学习网址 https://www.kotlincn.net/docs/reference/

 

因为我已经开始使用kotiln和java混合开发了,但有些小伙伴可能还在用java开发所以我也发一个java版本的

 

import java.io.File;  
import java.io.FileOutputStream;  
import java.io.PrintWriter;  
import java.io.StringWriter;  
import java.io.Writer;  
import java.lang.Thread.UncaughtExceptionHandler;  
import java.lang.reflect.Field;  
import java.text.DateFormat;  
import java.text.SimpleDateFormat;  
import java.util.Date;  
import java.util.HashMap;  
import java.util.Map;  
  
import android.content.Context;  
import android.content.pm.PackageInfo;  
import android.content.pm.PackageManager;  
import android.content.pm.PackageManager.NameNotFoundException;  
import android.os.Build;  
import android.os.Environment;  
import android.os.Looper;  
import android.util.Log;  
import android.widget.Toast;  
    
public class CrashHandler implements UncaughtExceptionHandler {  
      
    public static final String TAG = "CrashHandler";  
      
    //系统默认的UncaughtException处理类   
    private Thread.UncaughtExceptionHandler mDefaultHandler;  
    //CrashHandler实例  
    private static CrashHandler INSTANCE = new CrashHandler();  
    //程序的Context对象  
    private Context mContext;  
    //用来存储设备信息和异常信息  
    private Map<String, String> infos = new HashMap<String, String>();  
  
    //用于格式化日期,作为日志文件名的一部分  
    private DateFormat formatter = new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss");  
  
    /** 保证只有一个CrashHandler实例 */  
    private CrashHandler() {  
    }  
  
    /** 获取CrashHandler实例 ,单例模式 */  
    public static CrashHandler getInstance() {  
        return INSTANCE;  
    }  
  
    /** 
     * 初始化 
     *  
     * @param context 
     */  
    public void init(Context context) {  
        mContext = context;  
        //获取系统默认的UncaughtException处理器  
        mDefaultHandler = Thread.getDefaultUncaughtExceptionHandler();  
        //设置该CrashHandler为程序的默认处理器  
        Thread.setDefaultUncaughtExceptionHandler(this);  
    }  
  
    /** 
     * 当UncaughtException发生时会转入该函数来处理 
     */  
    @Override  
    public void uncaughtException(Thread thread, Throwable ex) {  
        if (!handleException(ex) && mDefaultHandler != null) {  
            //如果用户没有处理则让系统默认的异常处理器来处理  
            mDefaultHandler.uncaughtException(thread, ex);  
        } else {  
            try {  
                Thread.sleep(3000);  
            } catch (InterruptedException e) {  
                Log.e(TAG, "error : ", e);  
            }  
            //退出程序  
            android.os.Process.killProcess(android.os.Process.myPid());  
            System.exit(1);  
        }  
    }  
  
    /** 
     * 自定义错误处理,收集错误信息 发送错误报告等操作均在此完成. 
     *  
     * @param ex 
     * @return true:如果处理了该异常信息;否则返回false. 
     */  
    private boolean handleException(Throwable ex) {  
        if (ex == null) {  
            return false;  
        }  
        //使用Toast来显示异常信息  
        new Thread() {  
            @Override  
            public void run() {  
                Looper.prepare();  
                Toast.makeText(mContext, "很抱歉,程序出现异常,即将退出.", Toast.LENGTH_LONG).show();  
                Looper.loop();  
            }  
        }.start();  
        //收集设备参数信息   
        collectDeviceInfo(mContext);  
        //保存日志文件   
        saveCrashInfo2File(ex);  
        return true;  
    }  
      
    /** 
     * 收集设备参数信息 
     * @param ctx 
     */  
    public void collectDeviceInfo(Context ctx) {  
        try {  
            PackageManager pm = ctx.getPackageManager();  
            PackageInfo pi = pm.getPackageInfo(ctx.getPackageName(), PackageManager.GET_ACTIVITIES);  
            if (pi != null) {  
                String versionName = pi.versionName == null ? "null" : pi.versionName;  
                String versionCode = pi.versionCode + "";  
                infos.put("versionName", versionName);  
                infos.put("versionCode", versionCode);  
            }  
        } catch (NameNotFoundException e) {  
            Log.e(TAG, "an error occured when collect package info", e);  
        }  
        Field[] fields = Build.class.getDeclaredFields();  
        for (Field field : fields) {  
            try {  
                field.setAccessible(true);  
                infos.put(field.getName(), field.get(null).toString());  
                Log.d(TAG, field.getName() + " : " + field.get(null));  
            } catch (Exception e) {  
                Log.e(TAG, "an error occured when collect crash info", e);  
            }  
        }  
    }  
  
    /** 
     * 保存错误信息到文件中 
     *  
     * @param ex 
     * @return  返回文件名称,便于将文件传送到服务器 
     */  
    private String saveCrashInfo2File(Throwable ex) {  
          
        StringBuffer sb = new StringBuffer();  
        for (Map.Entry<String, String> entry : infos.entrySet()) {  
            String key = entry.getKey();  
            String value = entry.getValue();  
            sb.append(key + "=" + value + "\n");  
        }  
          
        Writer writer = new StringWriter();  
        PrintWriter printWriter = new PrintWriter(writer);  
        ex.printStackTrace(printWriter);  
        Throwable cause = ex.getCause();  
        while (cause != null) {  
            cause.printStackTrace(printWriter);  
            cause = cause.getCause();  
        }  
        printWriter.close();  
        String result = writer.toString();  
        sb.append(result);  
        try {  
            long timestamp = System.currentTimeMillis();  
            String time = formatter.format(new Date());  
            String fileName = "crash-" + time + "-" + timestamp + ".log";  
            if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {  
                String path = "/sdcard/crash/";  
                File dir = new File(path);  
                if (!dir.exists()) {  
                    dir.mkdirs();  
                }  
                FileOutputStream fos = new FileOutputStream(path + fileName);  
                fos.write(sb.toString().getBytes());  
                fos.close();  
            }  
            return fileName;  
        } catch (Exception e) {  
            Log.e(TAG, "an error occured while writing file...", e);  
        }  
        return null;  
    }  
}  

 

 

其实还有一些和很好的三方比如友盟,腾讯Bugly等.根据自己的需求使用