文章大纲

一、Android崩溃日志管理简介
二、崩溃日志管理实战
三、项目源码下载

 

一、Android崩溃日志管理简介

1. 什么是android崩溃日志管理

  开发中有些地方未注意可能造成异常抛出未能caught到，然后弹出系统对话框强制退出。这种交互不好，而且开发者也不能及时获取到底哪里出问题。因此我们可以使用android的UncaughtExceptionHandler来处理这种异常。

2. 操作逻辑

用户端（出现崩溃）
  我们会封装一个通用的jar包，该jar包包括日志打印、捕获异常信息逻辑、网络传输、设置Debug和Release模式、获取本机的相关信息等，当出现异常时，将异常信息以文件方式保存在用户手机中，并且发送到后台，当后台接收成功时，自动删除用户手机的崩溃信息文件，若接收失败，在下次发生崩溃时，将历史发送失败的崩溃一同发送。

接收端（后台）
  我们会编写一个地址，用于接收异常的具体信息，并储存在本地文件中，以此作为日志进行管理。

二、崩溃日志管理实战

1. 后台端

  在该实战中，我以简单的servlet进行讲解，实际项目中，可以以ssm或spring boot等框架进行操作。

  1. /**
  2.  * 接收崩溃信息，并进行打印（实际项目中，需要以文件形式归档）
  3.  * @author wxc
  4.  *
  5.  */
  6. public class Test extends HttpServlet {
  8.     public void doGet(HttpServletRequest request, HttpServletResponse response)
  9.             throws ServletException, IOException {
  11.         doPost(request, response);
  12.     }
  14.     public void doPost(HttpServletRequest request, HttpServletResponse response)
  15.             throws ServletException, IOException {
  17.         //获取客户端传送过来的信息流
  18.         BufferedReader in=new BufferedReader(new InputStreamReader(request.getInputStream()));
  20.         StringBuilder sb = new StringBuilder();   
  22.         String line = null; 
  24.         while ((line = in.readLine()) != null) {   
  26.                 //将信息流进行打印
  27.                System.out.println(line);
  28.         } 
  30.     }
  32. }

2. 客户端通用项目

网络请求相关的配置管理类：HttpManager.java

  1. /**
  2.  *
  3.  * 网络请求相关的配置管理
  4.  *
  5.  * @author 吴晓畅
  6.  *
  7.  */
  8. public class HttpManager {
  10.     private static final int SET_CONNECTION_TIMEOUT = 5 * 1000;
  11.     private static final int SET_SOCKET_TIMEOUT = 20 * 1000;
  13.     private static final String BOUNDARY = getBoundry();// UUID.randomUUID().toString();
  14.     private static final String MP_BOUNDARY = "--" + BOUNDARY;
  15.     private static final String END_MP_BOUNDARY = "--" + BOUNDARY + "--";
  16.     private static final String LINEND = "\r\n";
  18.     private static final String CHARSET = "UTF-8";
  20.     public static String uploadFile(String url, HttpParameters params,
  21.             File logFile) throws IOException{
  23.         HttpClient client = getHttpClient();
  25.         HttpPost post = new HttpPost(url);
  27.         ByteArrayOutputStream bos = null;
  29.         FileInputStream logFileInputStream = null;
  31.         String result = null;
  33.         try {
  35.             bos = new ByteArrayOutputStream();
  37.             if(params != null){
  38.                 String key = "";
  39.                 for (int i = 0; i < params.size(); i++) {
  40.                     key = params.getKey(i);
  41.                     StringBuilder temp = new StringBuilder(10);
  42.                     temp.setLength(0);
  43.                     temp.append(MP_BOUNDARY).append(LINEND);
  44.                     temp.append("content-disposition: form-data; name=\"").append(key)
  45.                             .append("\"").append(LINEND + LINEND);
  46.                     temp.append(params.getValue(key)).append(LINEND);
  47.                     bos.write(temp.toString().getBytes());
  48.                 }
  49.             }
  51.             StringBuilder temp = new StringBuilder();
  52.             temp.append(MP_BOUNDARY).append(LINEND);
  53.             temp.append(
  54.                     "content-disposition: form-data; name=\"logfile\"; filename=\"")
  55.                     .append(logFile.getName()).append("\"").append(LINEND);
  56.             temp.append("Content-Type: application/octet-stream; charset=utf-8").append(LINEND + LINEND);
  57.             bos.write(temp.toString().getBytes());
  58.             logFileInputStream = new FileInputStream(logFile);
  59.             byte[] buffer = new byte[1024*8];//8k
  60.             while(true){
  61.                 int count = logFileInputStream.read(buffer);
  62.                 if(count == -1){
  63.                     break;
  64.                 }
  65.                 bos.write(buffer, 0, count);
  66.             }
  68.             bos.write((LINEND+LINEND).getBytes());
  69.             bos.write((END_MP_BOUNDARY+LINEND).getBytes());
  71.             ByteArrayEntity formEntity = new ByteArrayEntity(bos.toByteArray());
  72.             post.setEntity(formEntity);
  73.             HttpResponse response = client.execute(post);
  74.             StatusLine status = response.getStatusLine();
  75.             int statusCode = status.getStatusCode();
  77.             Log.i("HttpManager", "返回结果为"+statusCode);
  78.             if(statusCode == HttpStatus.SC_OK){
  79.                 result = readHttpResponse(response);
  80.             }
  82.         } catch (IOException e) {
  83.             throw e;
  84.         }finally{
  85.             if(bos != null){
  86.                 try {
  87.                     bos.close();
  88.                 } catch (IOException e) {
  89.                     throw e;
  90.                 }
  91.             }
  92.             if(logFileInputStream != null){
  93.                 try {
  94.                     logFileInputStream.close();
  95.                 } catch (IOException e) {
  96.                     throw e;
  97.                 }
  98.             }
  99.         }
  101.         return result;
  102.     }
  104.     private static String readHttpResponse(HttpResponse response){
  105.         String result = null;
  106.         HttpEntity entity = response.getEntity();
  107.         InputStream inputStream;
  109.         try {
  110.             inputStream = entity.getContent();
  111.             ByteArrayOutputStream content = new ByteArrayOutputStream();
  112.             int readBytes = 0;
  113.             byte[] sBuffer = new byte[512];
  114.             while ((readBytes = inputStream.read(sBuffer)) != -1) {
  115.                 content.write(sBuffer, 0, readBytes);
  116.             }
  117.             result = new String(content.toByteArray(), CHARSET);
  118.             return result;
  120.         } catch (IllegalStateException e) {
  121.             // TODO Auto-generated catch block
  122.             e.printStackTrace();
  123.         } catch (IOException e) {
  124.             // TODO Auto-generated catch block
  125.             e.printStackTrace();
  126.         }
  127.         return result;
  129.     }
  131.     private static HttpClient getHttpClient() {
  133.         try {
  134.             KeyStore trustStore = KeyStore.getInstance(KeyStore
  135.                     .getDefaultType());
  136.             trustStore.load(null, null);
  137.             SSLSocketFactory sf = new MySSLSocketFactory(trustStore);
  138.             sf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
  139.             HttpParams params = new BasicHttpParams();
  141.             HttpConnectionParams.setConnectionTimeout(params, 10000);
  142.             HttpConnectionParams.setSoTimeout(params, 10000);
  144.             HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
  145.             HttpProtocolParams.setContentCharset(params, HTTP.UTF_8);
  147.             SchemeRegistry registry = new SchemeRegistry();
  148.             registry.register(new Scheme("http", PlainSocketFactory
  149.                     .getSocketFactory(), 80));
  150.             registry.register(new Scheme("https", sf, 443));
  152.             ClientConnectionManager ccm = new ThreadSafeClientConnManager(
  153.                     params, registry);
  155.             HttpConnectionParams.setConnectionTimeout(params,
  156.                     SET_CONNECTION_TIMEOUT);
  157.             HttpConnectionParams.setSoTimeout(params, SET_SOCKET_TIMEOUT);
  158.             HttpClient client = new DefaultHttpClient(ccm, params);
  159.             return client;
  160.         } catch (Exception e) {
  161.             // e.printStackTrace();
  162.             return new DefaultHttpClient();
  163.         }
  164.     }
  166.     private static class MySSLSocketFactory extends SSLSocketFactory {
  168.         SSLContext sslContext = SSLContext.getInstance("TLS");
  170.         public MySSLSocketFactory(KeyStore truststore)
  171.                 throws NoSuchAlgorithmException, KeyManagementException,
  172.                 KeyStoreException, UnrecoverableKeyException {
  173.             super(truststore);
  175.             TrustManager tm = new X509TrustManager() {
  177.                 @Override
  178.                 public X509Certificate[] getAcceptedIssuers() {
  179.                     // TODO Auto-generated method stub
  180.                     return null;
  181.                 }
  183.                 @Override
  184.                 public void checkServerTrusted(X509Certificate[] chain,
  185.                         String authType) throws CertificateException {
  186.                     // TODO Auto-generated method stub
  188.                 }
  190.                 @Override
  191.                 public void checkClientTrusted(X509Certificate[] chain,
  192.                         String authType) throws CertificateException {
  193.                     // TODO Auto-generated method stub
  195.                 }
  196.             };
  198.             sslContext.init(null, new TrustManager[] { tm }, null);
  199.         }
  201.         @Override
  202.         public Socket createSocket() throws IOException {
  203.             return sslContext.getSocketFactory().createSocket();
  204.         }
  206.         @Override
  207.         public Socket createSocket(Socket socket, String host, int port,
  208.                 boolean autoClose) throws IOException, UnknownHostException {
  209.             return sslContext.getSocketFactory().createSocket(socket, host,
  210.                     port, autoClose);
  211.         }
  213.     }
  215.     private static String getBoundry() {
  216.         StringBuffer _sb = new StringBuffer();
  217.         for (int t = 1; t < 12; t++) {
  218.             long time = System.currentTimeMillis() + t;
  219.             if (time % 3 == 0) {
  220.                 _sb.append((char) time % 9);
  221.             } else if (time % 3 == 1) {
  222.                 _sb.append((char) (65 + time % 26));
  223.             } else {
  224.                 _sb.append((char) (97 + time % 26));
  225.             }
  226.         }
  227.         return _sb.toString();
  228.     }
  229. }

文件上传相关类：UploadLogManager.java

  1. package com.qihoo.linker.logcollector.upload;
  3. import java.io.File;
  4. import java.io.IOException;
  5. import java.util.logging.Logger;
  7. import com.qihoo.linker.logcollector.capture.LogFileStorage;
  9. import android.content.Context;
  10. import android.os.Handler;
  11. import android.os.HandlerThread;
  12. import android.os.Looper;
  13. import android.os.Message;
  14. import android.util.Log;
  16. /**
  17.  *
  18.  * @author 吴晓畅
  19.  *
  20.  */
  21. public class UploadLogManager {
  23.     private static final String TAG = UploadLogManager.class.getName();
  25.     private static UploadLogManager sInstance;
  27.     private Context mContext;
  29.     private HandlerThread mHandlerThread;
  31.     private static volatile MyHandler mHandler;
  33.     private volatile Looper mLooper;
  35.     private volatile boolean isRunning = false;
  37.     private String url;
  39.     private HttpParameters params;
  41.     private UploadLogManager(Context c){
  42.         mContext = c.getApplicationContext();
  43.         mHandlerThread = new HandlerThread(TAG + ":HandlerThread");
  44.         mHandlerThread.start();
  46.     }
  48.     //初始化UploadLogManager类
  49.     public static synchronized UploadLogManager getInstance(Context c){
  50.         if(sInstance == null){
  51.             sInstance = new UploadLogManager(c);
  52.         }
  53.         return sInstance;
  54.     }
  56.     /**
  57.      * 执行文件上传具体操作
  58.      *
  59.      * @param url
  60.      * @param params
  61.      */
  62.     public void uploadLogFile(String url , HttpParameters params){
  63.         this.url = url;
  64.         this.params = params;
  66.         mLooper = mHandlerThread.getLooper();
  67.         mHandler = new MyHandler(mLooper);
  68.         if(mHandlerThread == null){
  69.             return;
  70.         }
  71.         if(isRunning){
  72.             return;
  73.         }
  74.         mHandler.sendMessage(mHandler.obtainMessage());
  75.         isRunning = true;
  76.     }
  78.     //用于uploadLogFile方法调用的线程
  79.     private final class MyHandler extends Handler{
  81.         public MyHandler(Looper looper) {
  82.             super(looper);
  83.             // TODO Auto-generated constructor stub
  84.         }
  86.         @Override
  87.         public void handleMessage(Message msg) {
  88.             File logFile = LogFileStorage.getInstance(mContext).getUploadLogFile();
  89.             if(logFile == null){
  90.                 isRunning = false;
  91.                 return;
  92.             }
  93.             try {
  94.                 String result = HttpManager.uploadFile(url, params, logFile);
  96.                 Log.i("UpLoad", "服务端返回数据为"+result);
  97.                 if(result != null){
  98.                     Boolean isSuccess = LogFileStorage.getInstance(mContext).deleteUploadLogFile();
  99.                     Log.i("UpLoad", "删除文件结果为"+isSuccess);
  100.                 }
  101.             } catch (IOException e) {
  102.                 // TODO Auto-generated catch block
  103.                 e.printStackTrace();
  104.             }finally{
  105.                 isRunning = false;
  106.             }
  107.         }
  109.     }
  111. }

客户端崩溃日志文件的删除，保存等操作类：LogFileStorage.java
文件保存在Android/data/包名/Log/下

  1. package com.qihoo.linker.logcollector.capture;
  3. import java.io.File;
  4. import java.io.FileOutputStream;
  6. import com.qihoo.linker.logcollector.utils.LogCollectorUtility;
  7. import com.qihoo.linker.logcollector.utils.LogHelper;
  9. import android.content.Context;
  10. import android.util.Log;
  12. /**
  13.  *
  14.  * 客户端崩溃日志文件的删除，保存等操作
  15.  *
  16.  * @author 吴晓畅
  17.  *
  18.  */
  19. public class LogFileStorage {
  21.     private static final String TAG = LogFileStorage.class.getName();
  23.     public static final String LOG_SUFFIX = ".log";
  25.     private static final String CHARSET = "UTF-8";
  27.     private static LogFileStorage sInstance;
  29.     private Context mContext;
  31.     private LogFileStorage(Context ctx) {
  32.         mContext = ctx.getApplicationContext();
  33.     }
  35.     public static synchronized LogFileStorage getInstance(Context ctx) {
  36.         if (ctx == null) {
  37.             LogHelper.e(TAG, "Context is null");
  38.             return null;
  39.         }
  40.         if (sInstance == null) {
  41.             sInstance = new LogFileStorage(ctx);
  42.         }
  43.         return sInstance;
  44.     }
  46.     public File getUploadLogFile(){
  47.         File dir = mContext.getFilesDir();
  48.         File logFile = new File(dir, LogCollectorUtility.getMid(mContext)
  49.                 + LOG_SUFFIX);
  50.         if(logFile.exists()){
  51.             return logFile;
  52.         }else{
  53.             return null;
  54.         }
  55.     }
  57.     //删除客户端中崩溃日志文件
  58.     public boolean deleteUploadLogFile(){
  59.         File dir = mContext.getFilesDir();
  60.         File logFile = new File(dir, LogCollectorUtility.getMid(mContext)
  61.                 + LOG_SUFFIX);
  62.         Log.i("Log",
  63.                 LogCollectorUtility.getMid(mContext)
  64.                 + LOG_SUFFIX);
  65.         return logFile.delete();
  66.     }
  68.     //保存文件
  69.     public boolean saveLogFile2Internal(String logString) {
  70.         try {
  71.             File dir = mContext.getFilesDir();
  72.             if (!dir.exists()) {
  73.                 dir.mkdirs();
  74.             }
  75.             File logFile = new File(dir, LogCollectorUtility.getMid(mContext)
  76.                     + LOG_SUFFIX);
  77.             FileOutputStream fos = new FileOutputStream(logFile , true);
  78.             fos.write(logString.getBytes(CHARSET));
  79.             fos.close();
  80.         } catch (Exception e) {
  81.             e.printStackTrace();
  82.             LogHelper.e(TAG, "saveLogFile2Internal failed!");
  83.             return false;
  84.         }
  85.         return true;
  86.     }
  88.     public boolean saveLogFile2SDcard(String logString, boolean isAppend) {
  89.         if (!LogCollectorUtility.isSDcardExsit()) {
  90.             LogHelper.e(TAG, "sdcard not exist");
  91.             return false;
  92.         }
  93.         try {
  94.             File logDir = getExternalLogDir();
  95.             if (!logDir.exists()) {
  96.                 logDir.mkdirs();
  97.             }
  99.             File logFile = new File(logDir, LogCollectorUtility.getMid(mContext)
  100.                     + LOG_SUFFIX);
  101.             /*if (!isAppend) {
  102.                 if (logFile.exists() && !logFile.isFile())
  103.                     logFile.delete();
  104.             }*/
  105.             LogHelper.d(TAG, logFile.getPath());
  107.             FileOutputStream fos = new FileOutputStream(logFile , isAppend);
  108.             fos.write(logString.getBytes(CHARSET));
  109.             fos.close();
  110.         } catch (Exception e) {
  111.             e.printStackTrace();
  112.             Log.e(TAG, "saveLogFile2SDcard failed!");
  113.             return false;
  114.         }
  115.         return true;
  116.     }
  118.     private File getExternalLogDir() {
  119.         File logDir = LogCollectorUtility.getExternalDir(mContext, "Log");
  120.         LogHelper.d(TAG, logDir.getPath());
  121.         return logDir;
  122.     }
  123. }

UncaughtExceptionHandler实现类：CrashHandler.java
  当出现异常时，会进入public void uncaughtException(Thread thread, Throwable ex) 方法中。

  1. /**
  2.  *
  3.  * 如果需要捕获系统的未捕获异常（如系统抛出了未知错误，这种异常没有捕获，这将导致系统莫名奇妙的关闭，使得用户体验差），
  4.  * 可以通过UncaughtExceptionHandler来处理这种异常。
  5.  *
  6.  * @author 吴晓畅
  7.  *
  8.  */
  9. public class CrashHandler implements UncaughtExceptionHandler {
  11.     private static final String TAG = CrashHandler.class.getName();
  13.     private static final String CHARSET = "UTF-8";
  15.     private static CrashHandler sInstance;
  17.     private Context mContext;
  19.     private Thread.UncaughtExceptionHandler mDefaultCrashHandler;
  21.     String appVerName;
  23.     String appVerCode;
  25.     String OsVer;
  27.     String vendor;
  29.     String model;
  31.     String mid;
  33.     //初始化该类
  34.     private CrashHandler(Context c) {
  35.         mContext = c.getApplicationContext();
  36.         // mContext = c;
  37.         appVerName = "appVerName:" + LogCollectorUtility.getVerName(mContext);
  38.         appVerCode = "appVerCode:" + LogCollectorUtility.getVerCode(mContext);
  39.         OsVer = "OsVer:" + Build.VERSION.RELEASE;
  40.         vendor = "vendor:" + Build.MANUFACTURER;
  41.         model = "model:" + Build.MODEL;
  42.         mid = "mid:" + LogCollectorUtility.getMid(mContext);
  43.     }
  45.     //初始化该类
  46.     public static CrashHandler getInstance(Context c) {
  47.         if (c == null) {
  48.             LogHelper.e(TAG, "Context is null");
  49.             return null;
  50.         }
  51.         if (sInstance == null) {
  52.             sInstance = new CrashHandler(c);
  53.         }
  54.         return sInstance;
  55.     }
  57.     public void init() {
  59.         if (mContext == null) {
  60.             return;
  61.         }
  63.         boolean b = LogCollectorUtility.hasPermission(mContext);
  64.         if (!b) {
  65.             return;
  66.         }
  67.         mDefaultCrashHandler = Thread.getDefaultUncaughtExceptionHandler();
  68.         Thread.setDefaultUncaughtExceptionHandler(this);
  69.     }
  71.     /**
  72.      * 发生异常时候进来这里
  73.      */
  74.     @Override
  75.     public void uncaughtException(Thread thread, Throwable ex) {
  76.         //
  77.         handleException(ex);
  78.         //
  79.         ex.printStackTrace();
  81.         if (mDefaultCrashHandler != null) {
  82.             mDefaultCrashHandler.uncaughtException(thread, ex);
  83.         } else {
  84.             Process.killProcess(Process.myPid());
  85.             // System.exit(1);
  86.         }
  87.     }
  89.     //将异常信息保存成文件
  90.     private void handleException(Throwable ex) {
  91.         String s = fomatCrashInfo(ex);
  92.         // String bes = fomatCrashInfoEncode(ex);
  93.         LogHelper.d(TAG, s);
  94.         // LogHelper.d(TAG, bes);
  95.         //LogFileStorage.getInstance(mContext).saveLogFile2Internal(bes);
  96.         LogFileStorage.getInstance(mContext).saveLogFile2Internal(s);
  97.         if(Constants.DEBUG){
  98.             LogFileStorage.getInstance(mContext).saveLogFile2SDcard(s, true);
  99.         }
  100.     }
  102.     private String fomatCrashInfo(Throwable ex) {
  104.         /*
  105.          * String lineSeparator = System.getProperty("line.separator");
  106.          * if(TextUtils.isEmpty(lineSeparator)){ lineSeparator = "\n"; }
  107.          */
  109.         String lineSeparator = "\r\n";
  111.         StringBuilder sb = new StringBuilder();
  112.         String logTime = "logTime:" + LogCollectorUtility.getCurrentTime();
  114.         String exception = "exception:" + ex.toString();
  116.         Writer info = new StringWriter();
  117.         PrintWriter printWriter = new PrintWriter(info);
  118.         ex.printStackTrace(printWriter);
  120.         String dump = info.toString();
  121.         String crashMD5 = "crashMD5:"
  122.                 + LogCollectorUtility.getMD5Str(dump);
  124.         String crashDump = "crashDump:" + "{" + dump + "}";
  125.         printWriter.close();
  127.         sb.append("&start---").append(lineSeparator);
  128.         sb.append(logTime).append(lineSeparator);
  129.         sb.append(appVerName).append(lineSeparator);
  130.         sb.append(appVerCode).append(lineSeparator);
  131.         sb.append(OsVer).append(lineSeparator);
  132.         sb.append(vendor).append(lineSeparator);
  133.         sb.append(model).append(lineSeparator);
  134.         sb.append(mid).append(lineSeparator);
  135.         sb.append(exception).append(lineSeparator);
  136.         sb.append(crashMD5).append(lineSeparator);
  137.         sb.append(crashDump).append(lineSeparator);
  138.         sb.append("&end---").append(lineSeparator).append(lineSeparator)
  139.                 .append(lineSeparator);
  141.         return sb.toString();
  143.     }
  145.     private String fomatCrashInfoEncode(Throwable ex) {
  147.         /*
  148.          * String lineSeparator = System.getProperty("line.separator");
  149.          * if(TextUtils.isEmpty(lineSeparator)){ lineSeparator = "\n"; }
  150.          */
  152.         String lineSeparator = "\r\n";
  154.         StringBuilder sb = new StringBuilder();
  155.         String logTime = "logTime:" + LogCollectorUtility.getCurrentTime();
  157.         String exception = "exception:" + ex.toString();
  159.         Writer info = new StringWriter();
  160.         PrintWriter printWriter = new PrintWriter(info);
  161.         ex.printStackTrace(printWriter);
  163.         String dump = info.toString();
  165.         String crashMD5 = "crashMD5:"
  166.                 + LogCollectorUtility.getMD5Str(dump);
  168.         try {
  169.             dump = URLEncoder.encode(dump, CHARSET);
  170.         } catch (UnsupportedEncodingException e) {
  171.             // TODO Auto-generated catch block
  172.             e.printStackTrace();
  173.         }
  174.         String crashDump = "crashDump:" + "{" + dump + "}";
  175.         printWriter.close();
  177.         sb.append("&start---").append(lineSeparator);
  178.         sb.append(logTime).append(lineSeparator);
  179.         sb.append(appVerName).append(lineSeparator);
  180.         sb.append(appVerCode).append(lineSeparator);
  181.         sb.append(OsVer).append(lineSeparator);
  182.         sb.append(vendor).append(lineSeparator);
  183.         sb.append(model).append(lineSeparator);
  184.         sb.append(mid).append(lineSeparator);
  185.         sb.append(exception).append(lineSeparator);
  186.         sb.append(crashMD5).append(lineSeparator);
  187.         sb.append(crashDump).append(lineSeparator);
  188.         sb.append("&end---").append(lineSeparator).append(lineSeparator)
  189.                 .append(lineSeparator);
  191.         String bes = Base64.encodeToString(sb.toString().getBytes(),
  192.                 Base64.NO_WRAP);
  194.         return bes;
  196.     }
  198. }

项目调用封装类：LogCollector.java

  1. /**
  2.  *
  3.  * 执行文件上传相关的类
  4.  *
  5.  *
  6.  * @author 吴晓畅
  7.  *
  8.  */
  9. public class LogCollector {
  11. private static final String TAG = LogCollector.class.getName();
  13.     private static String Upload_Url;
  15.     private static Context mContext;
  17.     private static boolean isInit = false;
  19.     private static HttpParameters mParams;
  21.     //初始化文件上传的url，数据等内容
  22.     public static void init(Context c , String upload_url , HttpParameters params){
  24.         if(c == null){
  25.             return;
  26.         }
  28.         if(isInit){
  29.             return;
  30.         }
  32.         Upload_Url = upload_url;
  33.         mContext = c;
  34.         mParams = params;
  36.         //初始化自己定义的异常处理
  37.         CrashHandler crashHandler = CrashHandler.getInstance(c);
  39.         crashHandler.init();
  41.         isInit = true;
  43.     }
  45.     /**
  46.      * 执行文件上传的网路请求
  47.      *
  48.      *  if(isWifiOnly && !isWifiMode){
  49.             return;
  50.         }表示只在wifi状态下执行文件上传
  51.      *
  52.      * @param isWifiOnly
  53.      */
  54.     public static void upload(boolean isWifiOnly){
  55.         if(mContext == null || Upload_Url == null){
  56.             Log.d(TAG, "please check if init() or not");
  57.             return;
  58.         }
  59.         if(!LogCollectorUtility.isNetworkConnected(mContext)){
  60.             return;
  61.         }
  63.         boolean isWifiMode = LogCollectorUtility.isWifiConnected(mContext);
  65.         if(isWifiOnly && !isWifiMode){
  66.             return;
  67.         }
  69.         UploadLogManager.getInstance(mContext).uploadLogFile(Upload_Url, mParams);
  70.     }
  72.     /**
  73.      * 用于设置是否为测试状态
  74.      *
  75.      * @param isDebug   true为是，false为否      如果是，能看到LOG日志，同时能够在将文件夹看到崩溃日志
  76.      */
  77.     public static void setDebugMode(boolean isDebug){
  79.         Constants.DEBUG = isDebug;
  81.         LogHelper.enableDefaultLog = isDebug;
  83.     }
  84. }

3. 客户端接入使用

为通用项目设置is Library模式

 
 

实际android项目使用

添加Library

 
 

在Application子类中进行初始化


  2. public class MyApplication extends Application {
  4.     //后台地址地址
  5.     private static final String UPLOAD_URL = "http://192.168.3.153:8080/bengkuitest/servlet/Test";
  7.     @Override
  8.     public void onCreate() {
  9.         super.onCreate();
  10.         boolean isDebug = true;
  12.         //设置是否为测试模式，如果是，同时能够在将文件夹看到崩溃日志
  13.         LogCollector.setDebugMode(isDebug);
  15.         //params的数据可以为空      初始化LogCollector的相关数据，用于文件上传到服务器
  16.         LogCollector.init(getApplicationContext(), UPLOAD_URL, null);
  17.     }
  19. }

编写异常并上传异常

  1. public class MainActivity extends Activity implements OnClickListener {
  3.     private Button btn_crash;
  5.     private Button btn_upload;
  7.     @Override
  8.     protected void onCreate(Bundle savedInstanceState) {
  9.         super.onCreate(savedInstanceState);
  10.         setContentView(R.layout.activity_main);
  12.         btn_crash = (Button) findViewById(R.id.button1);
  13.         btn_upload = (Button) findViewById(R.id.button2);
  14.         btn_crash.setOnClickListener(this);
  15.         btn_upload.setOnClickListener(this);
  17.     }
  19.     //产生异常
  20.     private void causeCrash(){
  21.         String s = null;
  22.         s.split("1");
  23.     }
  25.     //上传文件
  26.     private void uploadLogFile(){
  28.         //设置为只在wifi下上传文件
  29.         boolean isWifiOnly = true;//only wifi mode can upload
  31.         //执行文件上传服务器
  32.         LogCollector.upload(isWifiOnly);//upload at the right time
  33.     }
  35.     @Override
  36.     public void onClick(View v) {
  37.         switch (v.getId()) {
  38.         case R.id.button1:
  40.             causeCrash();
  41.             break;
  42.         case R.id.button2:
  44.             //上传文件
  45.             uploadLogFile();
  46.             break;
  48.         default:
  49.             break;
  50.         }
  51.     }
  53. }

运行结果如下图所示


  2. --No1Qr4Tu7Wx
  4. content-disposition: form-data; name="logfile"; filename="c5c63fec3651fdebdd411582793fa40c.log"
  5. Content-Type: application/octet-stream; charset=utf-8
  7. &start---
  8. logTime:2019-04-07 10:54:47
  9. appVerName:1.0
  10. appVerCode:1
  11. OsVer:5.1.1
  12. vendor:samsung
  13. model:SM-G955F
  14. mid:c5c63fec3651fdebdd411582793fa40c
  15. exception:java.lang.NullPointerException: Attempt to invoke virtual method 'java.lang.String[] java.lang.String.split(java.lang.String)' on a null object reference
  16. crashMD5:74861b8fb97ef57b82a87a826ab6b08f
  17. crashDump:{java.lang.NullPointerException: Attempt to invoke virtual method 'java.lang.String[] java.lang.String.split(java.lang.String)' on a null object reference
  18.     at com.jiabin.logcollectorexample.MainActivity.causeCrash(MainActivity.java:32)
  19.     at com.jiabin.logcollectorexample.MainActivity.onClick(MainActivity.java:45)
  20.     at android.view.View.performClick(View.java:4780)
  21.     at android.view.View$PerformClick.run(View.java:19866)
  22.     at android.os.Handler.handleCallback(Handler.java:739)
  23.     at android.os.Handler.dispatchMessage(Handler.java:95)
  24.     at android.os.Looper.loop(Looper.java:135)
  25.     at android.app.ActivityThread.main(ActivityThread.java:5293)
  26.     at java.lang.reflect.Method.invoke(Native Method)
  27.     at java.lang.reflect.Method.invoke(Method.java:372)
  28.     at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:903)
  29.     at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:698)
  30. }
  31. &end---
  33. --No1Qr4Tu7Wx--

三、项目源码下载

链接:https://pan.baidu.com/s/1kEGfJ3PSoDnsyulCAoimjg
密码:xy0l

 

Android之崩溃日志管理的更多相关文章

  1. 捕android程序崩溃日志

    主要类别: package com.example.callstatus; import java.io.File; import java.io.FileOutputStream; import j ...

  2. android app崩溃日志收集以及上传

    源代码获取请到github:https://github.com/DrJia/AndroidLogCollector 已经做成sdk的形式,源代码已公开,源代码看不懂的请自行google. 假设想定制 ...

  3. Android 简易崩溃日志保存

    仅仅做了简单的保存到了本地而已: 根据需要可以继续增加功能: 下一次启动上传到服务器: 增加应用版本,机型系统版本信息等: public class CrashSaver { public stati ...

  4. 保存android程序崩溃日志到SD卡

    private boolean writeToSDCard(Throwable ex) { boolean isDealing = false; if (Environment.getExternal ...

  5. iOS崩溃日志记录工具--CrashlyTics

    http://try.crashlytics.com Crashlytics优势: 1.Crashlytics基本不会漏掉任何应用崩溃的信息 2.Crashlytics对崩溃日志管理很人性化,会根据崩 ...

  6. 【Android应用开发】 Android 崩溃日志 本地存储 与 远程保存

    示例代码下载 : http://download.csdn.net/detail/han1202012/8638801; 一. 崩溃日志本地存储 1. 保存原理解析 崩溃信息本地保存步骤 : -- 1 ...

  7. android开发之应用Crash自动抓取Log_自动保存崩溃日志到本地

    http://blog.csdn.net/jason0539/article/details/45602655 应用发生crash之后要查看log,判断问题出在什么地方,可是一旦应用发布出去,就要想办 ...

  8. android的Log日志打印管理工具类(一)

    android的Log日志的打印管理工具类: package com.gzcivil.utils; import android.util.Log; /** * 日志打印管理 * * @author ...

  9. android 程序崩溃crash日志的捕捉

    android 程序崩溃crash日志的捕捉 之前在项目开发过程中,一直会遇到程序崩溃了,但是测试組的哥哥们又没及时的导出日志.... 后来在诳群的时候听别人说起,腾讯有那么一个叫bugly的东西 将 ...

随机推荐

  1. Eclipse从数据库逆向生成Hibernate实体类和映射文件（Eclipse插件系列之HibernateTools）

    ♣下载安装Eclipse插件(HibernateTools) ♣Eclipse连接数据库(Mysql5.7) ♣新建hibernate.properties和hibernate.cfg.xml文件 ♣ ...

  2. border-radius 详解及示例

    border-radius [ˈbɔrdə(r)] - [ˈrediəs]   英文示意: border:边界,国界,边疆 radius:半径,范围   定义: 复合写法: border-radius ...

  3. 26.app后端怎么架设推送服务

    推送服务已经是app的标配了.架设推送服务,除了可以使用第三方服务商外,也有大量的开源技术可以选择. 现在推送主要分两块,android推送和ios推送,在下面分别论述: 1.    Android推 ...

  4. 玩转Spring MVC(二)----MVC框架

    早期程序员在编写代码时是没有一个规范的,系统的业务逻辑和数据库的访问时混合在一起的,不仅增加了大量的重复工作,而且增加了后期维护的难度. 后来,人们逐渐发现某些通用的功能是可以单独的封装起来的,这样就 ...

  5. VMware12下CentOS 7安装教程

    CentOS 7 DVD安装光盘(百度搜索CentOS即可找到官方主页):VMware Workstation 12 Pro及以上软件: 启动VMware Workstation 12 Pro程序,在 ...

  6. Linux下*.tar.gz/.tar.bz2 文件解压缩安装命令

    1. .tar.gz压缩命令: 命令格式: tar -zcvf 压缩文件名.tar.gz 被压缩文件名 可先切换到当前目录下.压缩文件名和被压缩文件名都可加入路径. 2. .tar.gz解压缩命令: ...

  7. nsqlookup_protocol_v1.go

    , atomic.LoadInt64(&client.peerInfo.lastUpdate))         now := time.Now()         p.ctx.nsqlook ...

  8. txn.go

    package clientv3 import (     "sync"     pb "github.com/coreos/etcd/etcdserver/etcdse ...

  9. BZOJ_1100_[POI2007]对称轴osi_KMP+计算几何

    BZOJ_1100_[POI2007]对称轴osi_KMP+计算几何 Description FGD小朋友——一个闻名遐迩的年轻数学家——有一个小MM,yours.FGD小朋友非常喜欢他的MM,所以他 ...

  10. QTTabBar

    出处:https://www.mokeyjay.com/archives/1811