错误音讯捕获发送至服务器的详整,Android自定义捕获Application全局十一分

程序员最头疼的事情就是bug和debug。这次debug长达20天,搞的我心力交瘁。累,因为Android兼容性,不同手机会有不同的bug出来,而且很难复现,所以就上网找了下类似保存错误log到文件再上传到服务器,现把源码也共享出来。上传至服务器的代码我没加。相信大家都有现成的代码了。

本文转自:

先讲下原理,跟JavaEE的自定义异常捕获一样,将错误一直向上抛,然后在最上层统一处理。这里就可以获得Exception
Message,进行保存操作
异常捕获类如下:

 

复制代码 代码如下:

参考:

/**
 * @author Stay
 *      在Application中统一捕获异常,保存到文件中下次再打开时上传
 */
冠亚体育手机网站,public class CrashHandler implements UncaughtExceptionHandler {  
    /** 是否开启日志输出,在Debug状态下开启, 
     * 在Release状态下关闭以提示程序性能 
     * */ 
    public static final boolean DEBUG = true;  
    /** 系统默认的UncaughtException处理类 */ 
    private Thread.UncaughtExceptionHandler mDefaultHandler;  
    /** CrashHandler实例 */ 
    private static CrashHandler INSTANCE;  
    /** 程序的Context对象 */ 
//    private Context mContext;  
    /** 保证只有一个CrashHandler实例 */ 
    private CrashHandler() {}  
    /** 获取CrashHandler实例 ,单例模式*/ 
    public static CrashHandler getInstance() {  
        if (INSTANCE == null) {  
            INSTANCE = new CrashHandler();  
        }  
        return INSTANCE;  
    }  

Java代码
冠亚体育手机网站 1 冠亚体育手机网站 2冠亚体育手机网站 3)

    /** 
     * 初始化,注册Context对象, 
     * 获取系统默认的UncaughtException处理器, 
     * 设置该CrashHandler为程序的默认处理器 
     *  
     * @param ctx 
     */ 
    public void init(Context ctx) {  
//        mContext = ctx;  
        mDefaultHandler =
Thread.getDefaultUncaughtExceptionHandler();  
        Thread.setDefaultUncaughtExceptionHandler(this);  
    }  

  1. package qianlong.qlmobile.ui;   
  2.   
  3. import java.io.File;   
  4. import java.io.FileOutputStream;   
  5. import java.io.FilenameFilter;   
  6. import java.io.PrintWriter;   
  7. import java.io.StringWriter;   
  8. import java.io.Writer;   
  9. import java.lang.Thread.UncaughtExceptionHandler;
      
  10. import java.lang.reflect.Field;   
  11. import java.util.Arrays;   
  12. import java.util.Properties;   
  13. import java.util.TreeSet;   
  14.   
  15. import android.content.Context;   
  16. import android.content.pm.PackageInfo;
      
  17. import android.content.pm.PackageManager;   
  18. import android.content.pm.PackageManager.NameNotFoundException;
      
  19. import android.os.Build;   
  20. import android.os.Looper;   
  21. import android.text.format.Time;   
  22. import android.util.Log;   
  23. import android.view.Gravity;   
  24. import android.widget.Toast;   
  25.   
  26. public class CrashHandler implements UncaughtExceptionHandler {   
  27.   
  28.     /** Debug Log tag*/    
  29.     public static final String TAG = “CrashHandler”;    
  30.     /** 是否开启日志输出,在Debug状态下开启, 
     
  31.     * 在Release状态下关闭以提示程序性能 
     
  32.     * */    
  33.     public static final boolean DEBUG = false;    
  34.     /** 系统默认的UncaughtException处理类 */ 
      
  35.     private Thread.UncaughtExceptionHandler mDefaultHandler; 
      
  36.     /** CrashHandler实例 */    
  37.     private static CrashHandler INSTANCE;    
  38.     /** 程序的Context对象 */    
  39.     private Context mContext;    
  40.     /** 使用Properties来保存设备的信息和错误堆栈信息*/ 
      
  41.     private Properties mDeviceCrashInfo = new Properties();    
  42.     private static final String VERSION_NAME = “versionName”;    
  43.     private static final String VERSION_CODE = “versionCode”;    
  44.     private static final String STACK_TRACE = “STACK_TRACE”;    
  45.     /** 错误报告文件的扩展名 */    
  46.     private static final String CRASH_REPORTER_EXTENSION = “.cr”;    
  47.        
  48.     /** 保证只有一个CrashHandler实例 */    
  49.     private CrashHandler() {}    
  50.        
  51.     /** 获取CrashHandler实例 ,单例模式*/    
  52.     public static CrashHandler getInstance() {    
  53.         if (INSTANCE == null) {    
  54.             INSTANCE = new CrashHandler();    
  55.         }    
  56.         return INSTANCE;    
  57.     }    
  58.        
  59.     /**   
  60.     * 初始化,注册Context对象,   
  61.     * 获取系统默认的UncaughtException处理器, 
     
  62.     * 设置该CrashHandler为程序的默认处理器 
     
  63.     * @param ctx   
  64.     */    
  65.     public void init(Context ctx) {    
  66.         mContext = ctx;    
  67.         mDefaultHandler = Thread.getDefaultUncaughtExceptionHandler(); 
      
  68.         Thread.setDefaultUncaughtExceptionHandler(this);    
  69.     }    
  70.        
  71.     /**   
  72.     * 当UncaughtException发生时会转入该函数来处理 
     
  73.     */    
  74.     @Override    
  75.     public void uncaughtException(Thread thread, Throwable ex) { 
      
  76.         if (!handleException(ex) && mDefaultHandler != null) {    
  77.             //如果用户没有处理则让系统默认的异常处理器来处理 
      
  78.             mDefaultHandler.uncaughtException(thread, ex);    
  79.         } else {    
  80.             //Sleep一会后结束程序    
  81.             try {    
  82.                 Thread.sleep(5000);    
  83.             } catch (InterruptedException e) {    
  84.                 Log.e(TAG, “Error : “, e);    
  85.             }    
  86.             android.os.Process.killProcess(android.os.Process.myPid()); 
      
  87.             System.exit(10);    
  88.         }    
  89.     }    
  90.        
  91.     /**   
  92.     * 自定义错误处理,收集错误信息   
  93.     * 发送错误报告等操作均在此完成.   
  94.     * 开发者可以根据自己的情况来自定义异常处理逻辑 
     
  95.     * @param ex   
  96.     * @return true:如果处理了该异常信息;否则返回false 
     
  97.     */    
  98.     private boolean handleException(Throwable ex) {    
  99.         if (ex == null) {    
  100.             Log.w(TAG, “handleException — ex==null”);    
  101.             return true;    
  102.         }    
  103.         final String msg = ex.getLocalizedMessage(); 
      
  104.         if(msg == null) {   
  105.             return false;   
  106.         }   
  107.         //使用Toast来显示异常信息    
  108.         new Thread() {    
  109.             @Override    
  110.             public void run() {    
  111.                 Looper.prepare();    
  112.                 Toast toast = Toast.makeText(mContext, “程序出错,即将退出:\r\n” + msg,   
  113.                         Toast.LENGTH_LONG);   
  114.                 toast.setGravity(Gravity.CENTER, 0, 0);   
  115.                 toast.show();   
  116. //              MsgPrompt.showMsg(mContext, “程序出错啦”, msg+”\n点确认退出”);
      
  117.                 Looper.loop();    
  118.             }    
  119.         }.start();    
  120.         //收集设备信息    
  121.         collectCrashDeviceInfo(mContext);    
  122.         //保存错误报告文件    
  123.         saveCrashInfoToFile(ex);    
  124.         //发送错误报告到服务器    
  125.         //sendCrashReportsToServer(mContext);    
  126.         return true;    
  127.     }    
  128.        
  129.     /**   
  130.     * 在程序启动时候, 可以调用该函数来发送以前没有发送的报告 
     
  131.     */    
  132.     public void sendPreviousReportsToServer() {    
  133.         sendCrashReportsToServer(mContext);    
  134.     }    
  135.     /**   
  136.     * 把错误报告发送给服务器,包含新产生的和以前没发送的. 
     
  137.     * @param ctx   
  138.     */    
  139.     private void sendCrashReportsToServer(Context ctx) { 
      
  140.         String[] crFiles = getCrashReportFiles(ctx);    
  141.         if (crFiles != null && crFiles.length > 0) {    
  142.         TreeSet<String> sortedFiles = new TreeSet<String>();    
  143.         sortedFiles.addAll(Arrays.asList(crFiles));    
  144.         for (String fileName : sortedFiles) {    
  145.         File cr = new File(ctx.getFilesDir(), fileName);    
  146.         postReport(cr);    
  147.         cr.delete();// 删除已发送的报告 
      
  148.         }    
  149.         }    
  150.     }    
  151.     private void postReport(File file) {    
  152.         // TODO 发送错误报告到服务器 
      
  153.     }    
  154.        
  155.     /**   
  156.     * 获取错误报告文件名   
  157.     * @param ctx   
  158.     * @return   
  159.     */    
  160.     private String[] getCrashReportFiles(Context ctx) { 
      
  161.         File filesDir = ctx.getFilesDir();    
  162.         FilenameFilter filter = new FilenameFilter() {    
  163.             public boolean accept(File dir, String name) {    
  164.                 return name.endsWith(CRASH_REPORTER_EXTENSION); 
      
  165.             }    
  166.         };    
  167.         return filesDir.list(filter); 
      
  168.     }    
  169.        
  170.     /**   
  171.     * 保存错误信息到文件中   
  172.     * @param ex   
  173.     * @return   
  174.     */    
  175.     private String saveCrashInfoToFile(Throwable ex) { 
      
  176.         Writer info = new StringWriter();    
  177.         PrintWriter printWriter = new PrintWriter(info);    
  178.         ex.printStackTrace(printWriter);    
  179.         Throwable cause = ex.getCause();    
  180.         while (cause != null) {    
  181.             cause.printStackTrace(printWriter);    
  182.             cause = cause.getCause();    
  183.         }    
  184.         String result = info.toString();    
  185.         printWriter.close();    
  186.         mDeviceCrashInfo.put(“EXEPTION”, ex.getLocalizedMessage());   
  187.         mDeviceCrashInfo.put(STACK_TRACE, result);    
  188.         try {    
  189.             //long timestamp = System.currentTimeMillis(); 
      
  190.             Time t = new Time(“GMT+8”);    
  191.             t.setToNow(); // 取得系统时间
      
  192.             int date = t.year * 10000 + t.month * 100 + t.monthDay;   
  193.             int time = t.hour * 10000 + t.minute * 100 + t.second;   
  194.             String fileName = “crash-” + date + “-” + time + CRASH_REPORTER_EXTENSION;    
  195.             FileOutputStream trace = mContext.openFileOutput(fileName, 
      
  196.                     Context.MODE_PRIVATE);    
  197.             mDeviceCrashInfo.store(trace, “”);    
  198.             trace.flush();    
  199.             trace.close();    
  200.             return fileName;    
  201.         } catch (Exception e) {    
  202.             Log.e(TAG, “an error occured while writing report file…”, e); 
      
  203.         }    
  204.         return null;    
  205.     }    
  206.   
  207.     /**   
  208.     * 收集程序崩溃的设备信息   
  209.     *   
  210.     * @param ctx   
  211.     */    
  212.     public void collectCrashDeviceInfo(Context ctx) { 
      
  213.         try {    
  214.             PackageManager pm = ctx.getPackageManager();    
  215.             PackageInfo pi = pm.getPackageInfo(ctx.getPackageName(), 
      
  216.                     PackageManager.GET_ACTIVITIES);    
  217.             if (pi != null) {    
  218.                 mDeviceCrashInfo.put(VERSION_NAME,    
  219.                         pi.versionName == null ? “not set” : pi.versionName);    
  220.                 mDeviceCrashInfo.put(VERSION_CODE, “”+pi.versionCode);    
  221.             }    
  222.         } catch (NameNotFoundException e) {    
  223.             Log.e(TAG, “Error while collect package info”, e);    
  224.         }    
  225.         //使用反射来收集设备信息.在Build类中包含各种设备信息, 
      
  226.         //例如: 系统版本号,设备生产商 等帮助调试程序的有用信息 
      
  227.         //具体信息请参考后面的截图    
  228.         Field[] fields = Build.class.getDeclaredFields();    
  229.         for (Field field : fields) { 
      
  230.             try {    
  231.                 field.setAccessible(true);    
  232.                 mDeviceCrashInfo.put(field.getName(), “”+field.get(null));    
  233.                 if (DEBUG) {    
  234.                     Log.d(TAG, field.getName() + ” : ” + field.get(null));    
  235.                 }    
  236.             } catch (Exception e) { 
      
  237.                 Log.e(TAG, “Error while collect crash info”, e);    
  238.             }    
  239.         }    
  240.     }    
  241.   
  242. }  

    package qianlong.qlmobile.ui;

    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.FilenameFilter;
    import java.io.PrintWriter;
    import java.io.StringWriter;
    import java.io.Writer;
    import java.lang.Thread.UncaughtExceptionHandler;
    import java.lang.reflect.Field;
    import java.util.Arrays;
    import java.util.Properties;
    import java.util.TreeSet;

    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.Looper;
    import android.text.format.Time;
    import android.util.Log;
    import android.view.Gravity;
    import android.widget.Toast;

    public class CrashHandler implements UncaughtExceptionHandler {

    / Debug Log tag*/
    public static final String TAG = “CrashHandler”;
    /
    是否开启日志输出,在Debug状态下开启,

    • 在Release状态下关闭以提示程序性能
    • /
      public static final boolean DEBUG = false;
      /** 系统默认的UncaughtException处理类
      /
      private Thread.UncaughtExceptionHandler mDefaultHandler;
      / CrashHandler实例 */
      private static CrashHandler INSTANCE;
      /
      程序的Context对象 /
      private Context mContext;
      /** 使用Properties来保存设备的信息和错误堆栈信息
      /
      private Properties mDeviceCrashInfo = new Properties();
      private static final String VERSION_NAME = “versionName”;
      private static final String VERSION_CODE = “versionCode”;
      private static final String STACK_TRACE = “STACK_TRACE”;
      /* 错误报告文件的扩展名 /
      private static final String CRASH_REPORTER_EXTENSION = “.cr”;

      /* 保证只有一个CrashHandler实例 /
      private CrashHandler() {}

      /* 获取CrashHandler实例 ,单例模式/
      public static CrashHandler getInstance() {
      if (INSTANCE == null) {

        INSTANCE = new CrashHandler(); 
      

      }
      return INSTANCE;
      }

      /**

    • 初始化,注册Context对象,
    • 获取系统默认的UncaughtException处理器,
    • 设置该CrashHandler为程序的默认处理器
    • @param ctx
      */
      public void init(Context ctx) {
      mContext = ctx;
      mDefaultHandler = Thread.getDefaultUncaughtExceptionHandler();
      Thread.setDefaultUncaughtExceptionHandler(this);
      }

      /**

    • 当UncaughtException发生时会转入该函数来处理
      */
      @Override
      public void uncaughtException(Thread thread, Throwable ex) {
      if (!handleException(ex) && mDefaultHandler != null) {

        //如果用户没有处理则让系统默认的异常处理器来处理 
        mDefaultHandler.uncaughtException(thread, ex); 
      

      } else {

        //Sleep一会后结束程序 
        try { 
            Thread.sleep(5000); 
        } catch (InterruptedException e) { 
            Log.e(TAG, "Error : ", e); 
        } 
        android.os.Process.killProcess(android.os.Process.myPid()); 
        System.exit(10); 
      

      }
      }

      /**

    • 自定义错误处理,收集错误信息
    • 发送错误报告等操作均在此完成.
    • 开发者可以根据自己的情况来自定义异常处理逻辑
    • @param ex
    • @return true:如果处理了该异常信息;否则返回false
      */
      private boolean handleException(Throwable ex) {
      if (ex == null) {

        Log.w(TAG, "handleException --- ex==null"); 
        return true; 
      

      }
      final String msg = ex.getLocalizedMessage();
      if(msg == null) {

        return false;
      

      }
      //使用Toast来显示异常信息
      new Thread() {

        @Override 
        public void run() { 
            Looper.prepare(); 
            Toast toast = Toast.makeText(mContext, "程序出错,即将退出:\r\n" + msg,
                    Toast.LENGTH_LONG);
            toast.setGravity(Gravity.CENTER, 0, 0);
            toast.show();
      

      // MsgPrompt.showMsg(mContext, “程序出错啦”, msg+”\n点确认退出”);

            Looper.loop(); 
        } 
      

      }.start();
      //收集设备信息
      collectCrashDeviceInfo(mContext);
      //保存错误报告文件
      saveCrashInfoToFile(ex);
      //发送错误报告到服务器
      //sendCrashReportsToServer(mContext);
      return true;
      }

      /**

    • 在程序启动时候, 可以调用该函数来发送以前没有发送的报告
      */
      public void sendPreviousReportsToServer() {
      sendCrashReportsToServer(mContext);
      }
      /**
    • 把错误报告发送给服务器,包含新产生的和以前没发送的.
    • @param ctx
      */
      private void sendCrashReportsToServer(Context ctx) {
      String[] crFiles = getCrashReportFiles(ctx);
      if (crFiles != null && crFiles.length > 0) {
      TreeSet sortedFiles = new TreeSet();
      sortedFiles.addAll(Arrays.asList(crFiles));
      for (String fileName : sortedFiles) {
      File cr = new File(ctx.getFilesDir(), fileName);
      postReport(cr);
      cr.delete();// 删除已发送的报告
      }
      }
      }
      private void postReport(File file) {
      // TODO 发送错误报告到服务器
      }

      /**

    • 获取错误报告文件名
    • @param ctx
    • @return
      */
      private String[] getCrashReportFiles(Context ctx) {
      File filesDir = ctx.getFilesDir();
      FilenameFilter filter = new FilenameFilter() {

        public boolean accept(File dir, String name) { 
            return name.endsWith(CRASH_REPORTER_EXTENSION); 
        } 
      

      };
      return filesDir.list(filter);
      }

      /**

    • 保存错误信息到文件中
    • @param ex
    • @return
      */
      private String saveCrashInfoToFile(Throwable ex) {
      Writer info = new StringWriter();
      PrintWriter printWriter = new PrintWriter(info);
      ex.printStackTrace(printWriter);
      Throwable cause = ex.getCause();
      while (cause != null) {

        cause.printStackTrace(printWriter); 
        cause = cause.getCause(); 
      

      }
      String result = info.toString();
      printWriter.close();
      mDeviceCrashInfo.put(“EXEPTION”, ex.getLocalizedMessage());
      mDeviceCrashInfo.put(STACK_TRACE, result);
      try {

        //long timestamp = System.currentTimeMillis(); 
        Time t = new Time("GMT+8"); 
        t.setToNow(); // 取得系统时间
        int date = t.year * 10000 + t.month * 100 + t.monthDay;
        int time = t.hour * 10000 + t.minute * 100 + t.second;
        String fileName = "crash-" + date + "-" + time + CRASH_REPORTER_EXTENSION; 
        FileOutputStream trace = mContext.openFileOutput(fileName, 
                Context.MODE_PRIVATE); 
        mDeviceCrashInfo.store(trace, ""); 
        trace.flush(); 
        trace.close(); 
        return fileName; 
      

      } catch (Exception e) {

        Log.e(TAG, "an error occured while writing report file...", e); 
      

      }
      return null;
      }

      /**

    • 收集程序崩溃的设备信息
    • @param ctx
      */
      public void collectCrashDeviceInfo(Context ctx) {
      try {

        PackageManager pm = ctx.getPackageManager(); 
        PackageInfo pi = pm.getPackageInfo(ctx.getPackageName(), 
                PackageManager.GET_ACTIVITIES); 
        if (pi != null) { 
            mDeviceCrashInfo.put(VERSION_NAME, 
                    pi.versionName == null ? "not set" : pi.versionName); 
            mDeviceCrashInfo.put(VERSION_CODE, ""+pi.versionCode); 
        } 
      

      } catch (NameNotFoundException e) {

        Log.e(TAG, "Error while collect package info", e); 
      

      }
      //使用反射来收集设备信息.在Build类中包含各种设备信息,
      //例如: 系统版本号,设备生产商 等帮助调试程序的有用信息
      //具体信息请参考后面的截图
      Field[] fields = Build.class.getDeclaredFields();
      for (Field field : fields) {

        try { 
            field.setAccessible(true); 
            mDeviceCrashInfo.put(field.getName(), ""+field.get(null)); 
            if (DEBUG) { 
                Log.d(TAG, field.getName() + " : " + field.get(null)); 
            } 
        } catch (Exception e) { 
            Log.e(TAG, "Error while collect crash info", e); 
        } 
      

      }
      }

    }

    /** 
     * 当UncaughtException发生时会转入该函数来处理 
     */ 
    @Override 
    public void uncaughtException(Thread thread, Throwable ex) {  
        if (!handleException(ex) && mDefaultHandler != null) {  
            //如果用户没有处理则让系统默认的异常处理器来处理  
            mDefaultHandler.uncaughtException(thread, ex);  
        } else { 
//如果自己处理了异常,则不会弹出错误对话框,则需要手动退出app
            try {  
                Thread.sleep(3000);  
            } catch (InterruptedException e) {  
            }  
           
android.os.Process.killProcess(android.os.Process.myPid());  
            System.exit(10);  
        }  
    }  

Java代码
冠亚体育手机网站 4 冠亚体育手机网站 5冠亚体育手机网站 6)

    /** 
     * 自定义错误处理,收集错误信息 
     * 发送错误报告等操作均在此完成. 
     * 开发者可以根据自己的情况来自定义异常处理逻辑 
     * @return 
     * true代表处理该异常,不再向上抛异常,
     *
false代表不处理该异常(可以将该log信息存储起来)然后交给上层(这里就到了系统的异常处理)去处理,
     * 简单来说就是true不会弹出那个错误提示框,false就会弹出
     */ 
    private boolean handleException(final Throwable ex) {  
        if (ex == null) {  
            return false;  
        }  
//        final String msg = ex.getLocalizedMessage();  
        final StackTraceElement[] stack = ex.getStackTrace();
        final String message = ex.getMessage();
        //使用Toast来显示异常信息  
        new Thread() {  
            @Override 
            public void run() {  
                Looper.prepare();  
//                Toast.makeText(mContext, “程序出错啦:” + message,
Toast.LENGTH_LONG).show();  
//               
可以只创建一个文件,以后全部往里面append然后发送,这样就会有重复的信息,个人不推荐
                String fileName = “crash-” + System.currentTimeMillis() 

  1. 用法:   
  2. //全局数据存储   
  3. public class App extends Application {   
  4. private final static float HEAP_UTILIZATION = 0.75f;   
  5. private final static int MIN_HEAP_SIZE = 6* 1024* 1024 ;   
  6.    @Override  
  7.    public void onCreate() {   
  8.     super.onCreate();   
  9.            
  10.     // 异常处理,不需要处理时注释掉这两句即可!
      
  11.     CrashHandler crashHandler = CrashHandler.getInstance();    
  12.     // 注册crashHandler    
  13.     crashHandler.init(getApplicationContext());    
  14.            
  15.     // 优化内存,以下非必须!   
  16.     VMRuntime.getRuntime().setTargetHeapUtilization(HEAP_UTILIZATION);
      
  17.     VMRuntime.getRuntime().setMinimumHeapSize(MIN_HEAP_SIZE);    
  18.         //changeMetrics(this);//修改屏幕Density   
  19.         ……   
  20.    }   
  21. }  

    用法:
    //全局数据存储
    public class App extends Application {
    private final static float HEAP_UTILIZATION = 0.75f;
    private final static int MIN_HEAP_SIZE = 6 1024 1024 ;
    @Override
    public void onCreate() {

    super.onCreate();
    
    // 异常处理,不需要处理时注释掉这两句即可!
    CrashHandler crashHandler = CrashHandler.getInstance(); 
    // 注册crashHandler 
    crashHandler.init(getApplicationContext()); 
    
    // 优化内存,以下非必须!
    VMRuntime.getRuntime().setTargetHeapUtilization(HEAP_UTILIZATION);
    VMRuntime.getRuntime().setMinimumHeapSize(MIN_HEAP_SIZE); 
        //changeMetrics(this);//修改屏幕Density
        ......
    

    }

  • “.log”;  
                    File file = new
    File(Environment.getExternalStorageDirectory(), fileName);
                    try {
                        FileOutputStream fos = new
    FileOutputStream(file,true);
                        fos.write(message.getBytes());
                        for (int i = 0; i < stack.length; i++) {
                            fos.write(stack[i].toString().getBytes());
                        }
                        fos.flush();
                        fos.close();
                    } catch (Exception e) {
                    }
                    Looper.loop();  
                }  

异常时写入文件,下面是data/data中生成的文件:
冠亚体育手机网站 7

        }.start();  
        return false;  
    }  

Java代码
冠亚体育手机网站 8 冠亚体育手机网站 9冠亚体育手机网站 10)

    // TODO 使用HTTP Post 发送错误报告到服务器  这里不再赘述
//    private void postReport(File file) {  
//     
在上传的时候还可以将该app的version,该手机的机型等信息一并发送的服务器,
//     
Android的兼容性众所周知,所以可能错误不是每个手机都会报错,还是有针对性的去debug比较好
//    }  
}

  1. //   
  2. private static final boolean DebugFlag = false;   
  3. //修改屏幕Density   
  4. public static void changeMetrics(Context context) {   
  5.         DisplayMetrics curMetrics = context.getResources().getDisplayMetrics();
      
  6.         if(!DebugFlag) {   
  7.             if (curMetrics.densityDpi == DisplayMetrics.DENSITY_HIGH) {
      
  8.                 DisplayMetrics metrics = new DisplayMetrics();   
  9.                 metrics.scaledDensity = 1.0f;   
  10.                 metrics.density = 1.0f;
      
  11.                 metrics.densityDpi = DisplayMetrics.DENSITY_MEDIUM;
      
  12.                 metrics.xdpi = DisplayMetrics.DENSITY_MEDIUM;   
  13.                 metrics.ydpi = DisplayMetrics.DENSITY_MEDIUM;   
  14.                 metrics.heightPixels = curMetrics.heightPixels;   
  15.                 metrics.widthPixels = curMetrics.widthPixels;   
  16.                 context.getResources().getDisplayMetrics().setTo(metrics);
      
  17.             }   
  18.         } else {   
  19.             DisplayMetrics metrics = new DisplayMetrics();   
  20.             metrics.scaledDensity = (float)(130/160.0);   
  21.             metrics.density = (float)(130/160.0);   
  22.             metrics.densityDpi = 130;   
  23.             metrics.xdpi = 130;   
  24.             metrics.ydpi = 130;   
  25.             metrics.heightPixels = curMetrics.heightPixels;   
  26.             metrics.widthPixels = curMetrics.widthPixels;   
  27.             context.getResources().getDisplayMetrics().setTo(metrics);
      
  28.         }   
  29. }  

    //
    private static final boolean DebugFlag = false;
    //修改屏幕Density
    public static void changeMetrics(Context context) {

        DisplayMetrics curMetrics = context.getResources().getDisplayMetrics();
        if(!DebugFlag) {
            if (curMetrics.densityDpi == DisplayMetrics.DENSITY_HIGH) {
                DisplayMetrics metrics = new DisplayMetrics();
                metrics.scaledDensity = 1.0f;
                metrics.density = 1.0f;
                metrics.densityDpi = DisplayMetrics.DENSITY_MEDIUM;
                metrics.xdpi = DisplayMetrics.DENSITY_MEDIUM;
                metrics.ydpi = DisplayMetrics.DENSITY_MEDIUM;
                metrics.heightPixels = curMetrics.heightPixels;
                metrics.widthPixels = curMetrics.widthPixels;
                context.getResources().getDisplayMetrics().setTo(metrics);
            }
        } else {
            DisplayMetrics metrics = new DisplayMetrics();
            metrics.scaledDensity = (float)(130/160.0);
            metrics.density = (float)(130/160.0);
            metrics.densityDpi = 130;
            metrics.xdpi = 130;
            metrics.ydpi = 130;
            metrics.heightPixels = curMetrics.heightPixels;
            metrics.widthPixels = curMetrics.widthPixels;
            context.getResources().getDisplayMetrics().setTo(metrics);
        }
    

    }

在Application
onCreate时就注册ExceptionHandler,此后只要程序在抛异常后就能捕获到。

 

复制代码 代码如下:

public class App extends Application{
        @Override 
        public void onCreate() {  
            super.onCreate();  
            CrashHandler crashHandler = CrashHandler.getInstance();  
            //注册crashHandler  
            crashHandler.init(getApplicationContext());  
        }  
}
?public class LogActivity extends Activity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        try {//制造bug
            File file = new File(Environment.getExternalStorageState()
,”crash.bin”);
            FileInputStream fis = new FileInputStream(file);
            byte[] buffer = new byte[1024];
            fis.read(buffer);
        } catch (Exception e) {
           
//这里不能再向上抛异常,如果想要将log信息保存起来,则抛出runtime异常,
//          让自定义的handler来捕获,统一将文件保存起来上传
            throw new RuntimeException(e);
        }
    }
}

注意,如果catch后不throw就默认是自己处理了,ExceptionHandler不会捕获异常了。 再分享一个Log的封装类,只要在这里设置DEBUG的值就能让控制台是否打印出log

复制代码 代码如下:

public class DebugUtil {
    public static final String TAG = “ICON”;
    public static final boolean DEBUG = true;

    public static void toast(Context context,String content){
        Toast.makeText(context, content, Toast.LENGTH_SHORT).show();
    }

    public static void debug(String tag,String msg){
        if (DEBUG) {
            Log.d(tag, msg);
        }
    }

    public static void debug(String msg){
        if (DEBUG) {
            Log.d(TAG, msg);
        }
    }

    public static void error(String tag,String error){
        Log.e(tag, error);
    }

    public static void error(String error){
        Log.e(TAG, error);
    }
}

您可能感兴趣的文章:

  • Android上传文件到Web服务器
    PHP接收文件
  • Android使用第三方服务器Bmob实现发送短信验证码
  • Android使用httpPost向服务器发送请求的方法
  • Android编程向服务器发送请求时出现中文乱码问题的解决方法
  • Android发送xml数据给服务器的方法
  • Android向node.js编写的服务器发送数据并接收请求

Post Author: admin

发表评论

电子邮件地址不会被公开。 必填项已用*标注