Android 捕捉app系统中未处理的异常

一：为什么要处理？

其实我们都知道，在开发过程中，自己的app系统或许有许多隐藏的异常，自己没有捕捉到，那么关于异常的捕捉，这是相当重要的，如果系统发生崩溃，那么至少也可以让系统挂在系统之内，不会发现什么系统直接退了，或者是卡死，这样做，能够使得用户体验效果更加，自己也可以发现用户到底出现什么异常，便于自己以后好处理这个问题，优化处理自己的系统。

二：如何解决

在Android 开发中，自身其实带有一个系统默认的异常处理接口，UncaughtExceptionHandler，该接口呢，能够很好的处理程序中发生的异常，所以，往往开发者都喜欢使用它，而且它也是一个非常简单好用的东西。

三：具体实现

（1）实现UncaughtExceptionHandler接口的类

package com.x1.tools;  
  
import java.lang.Thread.UncaughtExceptionHandler;  
  
import android.app.ActivityManager;  
import android.content.ComponentName;  
import android.content.Context;  
import android.os.Looper;  
import android.util.Log;  
  
import com.x1.dao.SubmitConfigBugs;  
import com.x1.ui.R;  
  
/** 
 * 未捕获异常捕捉类 
 *  
 * @author zengtao 2015年5月6日 
 * 
 * 
 */  
public class CrashHandlers implements UncaughtExceptionHandler {  
  
    public static final String TGA = "CrashHandlers";  
  
    // 系统默认的UncaughtException处理类  
    private Thread.UncaughtExceptionHandler mDefaultHandler;  
  
    // CrashHandler实例  
    private static CrashHandlers instance;  
    // 程序的Context对象  
    private Context mContext;  
  
    private GetPhoneInfo phone;  
  
    /** 保证只有一个CrashHandler实例 */  
    private CrashHandlers() {  
    }  
  
    /** 获取CrashHandler实例 ,单例模式 */  
    public synchronized static CrashHandlers getInstance() {  
        if (instance == null) {  
            instance = new CrashHandlers();  
        }  
        return instance;  
    }  
  
    /** 
     * 初始化 
     *  
     * @param context 
     */  
    public void init(Context context) {  
        mContext = context;  
        // 获取系统默认的UncaughtException处理器  
        mDefaultHandler = Thread.getDefaultUncaughtExceptionHandler();  
        // 设置该CrashHandler为程序的默认处理器  
        Thread.setDefaultUncaughtExceptionHandler(this);  
        phone = new GetPhoneInfo(context);  
    }  
  
    /** 
     * 当UncaughtException发生时会转入该函数来处理 
     */  
    @Override  
    public void uncaughtException(Thread thread, Throwable ex) {  
        if (!handleException(thread, ex) && mDefaultHandler != null) {  
            // 如果用户没有处理则让系统默认的异常处理器来处理  
            mDefaultHandler.uncaughtException(thread, ex);  
        } else {  
            try {  
                Thread.sleep(3000);  
            } catch (InterruptedException e) {  
                Log.e(TGA, e.toString());  
            }  
            // 退出程序  
            android.os.Process.killProcess(android.os.Process.myPid());  
            System.exit(1);  
        }  
    }  
  
    /** 
     * 自定义错误处理,收集错误信息 发送错误报告等操作均在此完成. 
     *  
     * @param ex 
     * @return true:如果处理了该异常信息;否则返回false. 
     */  
    private boolean handleException(Thread thread, Throwable ex) {  
        if (ex == null) {  
            return false;  
        }  
        // 使用Toast来显示异常信息  
        new Thread() {  
            @Override  
            public void run() {  
                Looper.prepare();  
                ShowToast.show(mContext, "喵,很抱歉,程序出现异常,即将退出!",  
                        R.drawable.error_icon);  
                Looper.loop();  
            }  
        }.start();  
        // 把异常信息和设备信息上传到服务器  
        subMitThreadAndDeviceInfo(mContext, thread, ex);  
        return true;  
    }  
  
    // 提交信息到服务器  
    public void subMitThreadAndDeviceInfo(Context ctx, Thread thread,  
            Throwable ex) {  
        // 当前用户的账号  
        String Account = null;  
        if (Config.getCachedAccount(ctx) != null) {  
            Account = Config.getCachedAccount(ctx);  
        } else {  
            Account = "当前无用户登录";  
        }  
        // 手机设备的信息  
        String PhoneModel = phone.PhoneModel;  
        String PhoneVersion = phone.PhoneVersion;  
        String PhoneResolution = phone.PhoneResolution;  
        String ZcmVersion = phone.ZcmVersion;  
        String AvailableRom = phone.AvailableRom;  
        // 获取当前显示在界面上的Activity的路径加类名  
        ActivityManager am = (ActivityManager) ctx  
                .getSystemService(Context.ACTIVITY_SERVICE);  
        ComponentName cn = am.getRunningTasks(1).get(0).topActivity;  
        // 异常信息加异常所在类的绝对路径  
        final String content = "thread: " + thread + " , name: "  
                + thread.getName() + ", id: " + thread.getId()  
                + ", exception: " + ex + ", " + cn.getClassName();  
  
        // 执行接口,把异常信息提交到服务器  
        new SubmitConfigBugs(0, ctx, Account, PhoneModel, PhoneVersion,  
                PhoneResolution, ZcmVersion, AvailableRom, content,  
                new SubmitConfigBugs.SuccessCallback() {  
                    @Override  
                    public void onSuccess() {  
                        Log.e(TGA, content + "
错误信息提交成功");  
                    }  
                }, new SubmitConfigBugs.FailCallback() {  
  
                    @Override  
                    public void onFail() {  
                        Log.e(TGA, content + "
错误信息提交失败");  
                    }  
                });  
    }  
  
}

（2）实体类：手机信息

package com.x1.tools;  
  
import android.content.Context;  
import android.content.pm.PackageInfo;  
import android.content.pm.PackageManager;  
import android.os.Environment;  
import android.os.StatFs;  
import android.text.TextUtils;  
import android.view.Display;  
import android.view.WindowManager;  
  
/** 
 * 获取当前手机的设备信息和当前软件的版本 
 *  
 * @author zengtao 2015年5月6日 
 * 
 * 
 */  
public class GetPhoneInfo {  
    private Context context;  
    public String PhoneModel;  
    public String PhoneVersion;  
    public String PhoneResolution;  
    public String ZcmVersion;  
    public String AvailableRom;  
  
    public GetPhoneInfo(Context context) {  
        this.context = context;  
        PhoneModel = android.os.Build.MODEL;  
        PhoneVersion = android.os.Build.VERSION.RELEASE;  
        PhoneResolution = getDisplayWAndH();  
        ZcmVersion = getAppVersionName(this.context);  
        AvailableRom = "ROM剩余存储空间: " + getAvailableInternalMemorySize() + "MB"  
                + ",内置SDCard剩余存储空间: " + getAvailableExternalMemorySize() + "MB";  
    }  
  
    // 获取当前版本号  
    private String getAppVersionName(Context context) {  
        String versionName = "";  
        try {  
            PackageManager packageManager = context.getPackageManager();  
            PackageInfo packageInfo = packageManager.getPackageInfo(  
                    "com.x1.ui", 0);  
            versionName = packageInfo.versionName;  
            if (TextUtils.isEmpty(versionName)) {  
                return "";  
            }  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
        return versionName;  
    }  
  
    // 获取屏幕分辨率  
    @SuppressWarnings("deprecation")  
    private String getDisplayWAndH() {  
        WindowManager wm = (WindowManager) context  
                .getSystemService(Context.WINDOW_SERVICE);  
        Display display = wm.getDefaultDisplay();  
        String string = "屏幕分辨率: " + display.getWidth() + "x"  
                + display.getHeight();  
        return string;  
    }  
  
    /** 
     *  
     * @return ROM存储路径 
     */  
    private String getInternalMemoryPath() {  
        return Environment.getDataDirectory().getPath();  
    }  
  
    /** 
     *  
     * @return 内置sd卡路径 
     */  
    private String getExternalMemoryPath() {  
        return Environment.getExternalStorageDirectory().getPath();  
    }  
  
    /** 
     *  
     * @param path 
     *            文件路径 
     * @return 文件路径的StatFs对象 
     * @throws Exception 
     *             路径为空或非法异常抛出 
     */  
    private StatFs getStatFs(String path) {  
        try {  
            return new StatFs(path);  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
        return null;  
    }  
  
    /** 
     *  
     * @param stat 
     *            文件StatFs对象 
     * @return 剩余存储空间的MB数 
     *  
     */  
    @SuppressWarnings("deprecation")  
    private float calculateSizeInMB(StatFs stat) {  
        if (stat != null)  
            return stat.getAvailableBlocks()  
                    * (stat.getBlockSize() / (1024f * 1024f));  
        return 0.0f;  
    }  
  
    /** 
     *  
     * @return ROM剩余存储空间的MB数 
     */  
    private float getAvailableInternalMemorySize() {  
  
        String path = getInternalMemoryPath();// 获取数据目录  
        StatFs stat = getStatFs(path);  
        return calculateSizeInMB(stat);  
    }  
  
    /** 
     *  
     * @return 内置SDCard剩余存储空间MB数 
     */  
    private float getAvailableExternalMemorySize() {  
  
        String path = getExternalMemoryPath();// 获取数据目录  
        StatFs stat = getStatFs(path);  
        return calculateSizeInMB(stat);  
  
    }  
}

　　

  1. package com.x1.tools;  
  2.   
  3. import java.lang.Thread.UncaughtExceptionHandler;  
  4.   
  5. import android.app.ActivityManager;  
  6. import android.content.ComponentName;  
  7. import android.content.Context;  
  8. import android.os.Looper;  
  9. import android.util.Log;  
  10.   
  11. import com.x1.dao.SubmitConfigBugs;  
  12. import com.x1.ui.R;  
  13.   
  14. /** 
  15.  * 未捕获异常捕捉类 
  16.  *  
  17.  * @author zengtao 2015年5月6日 
  18.  * 
  19.  * 
  20.  */  
  21. public class CrashHandlers implements UncaughtExceptionHandler {  
  22.   
  23.     public static final String TGA = "CrashHandlers";  
  24.   
  25.     // 系统默认的UncaughtException处理类  
  26.     private Thread.UncaughtExceptionHandler mDefaultHandler;  
  27.   
  28.     // CrashHandler实例  
  29.     private static CrashHandlers instance;  
  30.     // 程序的Context对象  
  31.     private Context mContext;  
  32.   
  33.     private GetPhoneInfo phone;  
  34.   
  35.     /** 保证只有一个CrashHandler实例 */  
  36.     private CrashHandlers() {  
  37.     }  
  38.   
  39.     /** 获取CrashHandler实例 ,单例模式 */  
  40.     public synchronized static CrashHandlers getInstance() {  
  41.         if (instance == null) {  
  42.             instance = new CrashHandlers();  
  43.         }  
  44.         return instance;  
  45.     }  
  46.   
  47.     /** 
  48.      * 初始化 
  49.      *  
  50.      * @param context 
  51.      */  
  52.     public void init(Context context) {  
  53.         mContext = context;  
  54.         // 获取系统默认的UncaughtException处理器  
  55.         mDefaultHandler = Thread.getDefaultUncaughtExceptionHandler();  
  56.         // 设置该CrashHandler为程序的默认处理器  
  57.         Thread.setDefaultUncaughtExceptionHandler(this);  
  58.         phone = new GetPhoneInfo(context);  
  59.     }  
  60.   
  61.     /** 
  62.      * 当UncaughtException发生时会转入该函数来处理 
  63.      */  
  64.     @Override  
  65.     public void uncaughtException(Thread thread, Throwable ex) {  
  66.         if (!handleException(thread, ex) && mDefaultHandler != null) {  
  67.             // 如果用户没有处理则让系统默认的异常处理器来处理  
  68.             mDefaultHandler.uncaughtException(thread, ex);  
  69.         } else {  
  70.             try {  
  71.                 Thread.sleep(3000);  
  72.             } catch (InterruptedException e) {  
  73.                 Log.e(TGA, e.toString());  
  74.             }  
  75.             // 退出程序  
  76.             android.os.Process.killProcess(android.os.Process.myPid());  
  77.             System.exit(1);  
  78.         }  
  79.     }  
  80.   
  81.     /** 
  82.      * 自定义错误处理,收集错误信息 发送错误报告等操作均在此完成. 
  83.      *  
  84.      * @param ex 
  85.      * @return true:如果处理了该异常信息;否则返回false. 
  86.      */  
  87.     private boolean handleException(Thread thread, Throwable ex) {  
  88.         if (ex == null) {  
  89.             return false;  
  90.         }  
  91.         // 使用Toast来显示异常信息  
  92.         new Thread() {  
  93.             @Override  
  94.             public void run() {  
  95.                 Looper.prepare();  
  96.                 ShowToast.show(mContext, "喵,很抱歉,程序出现异常,即将退出!",  
  97.                         R.drawable.error_icon);  
  98.                 Looper.loop();  
  99.             }  
  100.         }.start();  
  101.         // 把异常信息和设备信息上传到服务器  
  102.         subMitThreadAndDeviceInfo(mContext, thread, ex);  
  103.         return true;  
  104.     }  
  105.   
  106.     // 提交信息到服务器  
  107.     public void subMitThreadAndDeviceInfo(Context ctx, Thread thread,  
  108.             Throwable ex) {  
  109.         // 当前用户的账号  
  110.         String Account = null;  
  111.         if (Config.getCachedAccount(ctx) != null) {  
  112.             Account = Config.getCachedAccount(ctx);  
  113.         } else {  
  114.             Account = "当前无用户登录";  
  115.         }  
  116.         // 手机设备的信息  
  117.         String PhoneModel = phone.PhoneModel;  
  118.         String PhoneVersion = phone.PhoneVersion;  
  119.         String PhoneResolution = phone.PhoneResolution;  
  120.         String ZcmVersion = phone.ZcmVersion;  
  121.         String AvailableRom = phone.AvailableRom;  
  122.         // 获取当前显示在界面上的Activity的路径加类名  
  123.         ActivityManager am = (ActivityManager) ctx  
  124.                 .getSystemService(Context.ACTIVITY_SERVICE);  
  125.         ComponentName cn = am.getRunningTasks(1).get(0).topActivity;  
  126.         // 异常信息加异常所在类的绝对路径  
  127.         final String content = "thread: " + thread + " , name: "  
  128.                 + thread.getName() + ", id: " + thread.getId()  
  129.                 + ", exception: " + ex + ", " + cn.getClassName();  
  130.   
  131.         // 执行接口,把异常信息提交到服务器  
  132.         new SubmitConfigBugs(0, ctx, Account, PhoneModel, PhoneVersion,  
  133.                 PhoneResolution, ZcmVersion, AvailableRom, content,  
  134.                 new SubmitConfigBugs.SuccessCallback() {  
  135.                     @Override  
  136.                     public void onSuccess() {  
  137.                         Log.e(TGA, content + " 错误信息提交成功");  
  138.                     }  
  139.                 }, new SubmitConfigBugs.FailCallback() {  
  140.   
  141.                     @Override  
  142.                     public void onFail() {  
  143.                         Log.e(TGA, content + " 错误信息提交失败");  
  144.                     }  
  145.                 });  
  146.     }  
  147.   
  148. } 
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/foxy/p/7815753.html