Android—— LogCat、StrictMode、全局捕获异常

最新推荐文章于 2023-01-26 23:11:32 发布

走慢一点点

最新推荐文章于 2023-01-26 23:11:32 发布

阅读量999

点赞数 1

分类专栏： Android基础文章标签： android 调试日志严苛模式全局捕获异常

本文链接：https://blog.csdn.net/wuseyukui/article/details/49149747

版权

Android基础专栏收录该内容

34 篇文章 1 订阅

订阅专栏

严苛模式（StrictMode）

Android 2.3提供一个称为严苛模式（StrictMode）的调试特性，它将报告与线程及虚拟机相关的策略违例。StrictMode提供了各种的策略，这些策略能随时检查和报告开发者开发应用中存在的问题。

StrictMode的策略和规则
目前，有两大类的策略可供使用，一类是关于线程监控方面的，另外一类是关于VM虚拟机等方面的策略。

常用的线程监控方面的策略有：

Disk Reads 磁盘读
Disk Writes 磁盘写
Network access 网络访问
Custom Slow Code 自定义的运行速度慢的代码分析

常用的VM虚拟机策略有：

内存泄露的Activity对象
内存泄露的SQLite对象
内存泄露的释放的对象

使用示例：

  import android.os.StrictMode;

  @Override
  protected void onCreate(Bundle savedInstanceState) {
      openStrictMode();
      ...
  }

  ...

 private void openStrictMode() {
      // 仅在调试模式设置严苛模式（StrictMode）
      if (HYConfig.DEBUG) {
          // 检测与线程相关的策略违例
          StrictMode.setThreadPolicy(new StrictMode.ThreadPolicy.Builder()
                  .detectAll()// 检测所有策略
                  .permitDiskReads()// 屏蔽磁盘读策略
                  .permitDiskWrites()// 屏蔽磁盘写策略
                  .permitNetwork()// 屏蔽网络访问策略
                  .penaltyLog()// 表示将警告输出到LogCat
                  .penaltyDeath()// 一旦StrictMode消息被写到LogCat后应用就会崩溃
                  .build());

          // 检测与虚拟机相关的策略违例
          StrictMode.setVmPolicy(new StrictMode.VmPolicy.Builder()
                  .detectAll()
                  .penaltyLog()
                  .build());
      }
  }

内存检查日志

public static void displayBriefMemory(String name, Context context) {

        final ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);

        ActivityManager.MemoryInfo info = new ActivityManager.MemoryInfo();

        activityManager.getMemoryInfo(info);

        MyLog.d("MyLog","=========内存检查: name="+name);

        MyLog.d("MyLog","=========系统剩余内存:"+(info.availMem));

        MyLog.d("MyLog", "=========系统是否处于低内存运行：" + info.lowMemory);

        MyLog.d("MyLog","=========当系统剩余内存低于"+info.threshold+"时就看成低内存运行");

    }

自定义日志打印类

package cn.toltech.treefrog.util;

import android.text.TextUtils;
import android.util.Log;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

import cn.toltech.treefrog.HYConfig;

/**
 * 描述：自定义日志打印类
 * 可控开关的日志调试，并可以输出到文件
 * Created by huangyk on 2016/1/14.
 */
public class LogUtils {

    private static String TAG = "LogUtils";

    // 日志输出级别E
    public static final int LEVEL_ERROR = 1;
    // 日志输出级别W
    public static final int LEVEL_WARN = 2;
    // 日志输出级别I
    public static final int LEVEL_INFO = 3;
    // 日志输出级别D
    public static final int LEVEL_DEBUG = 4;
    // 日志输出级别V
    public static final int LEVEL_VERBOSE = 5;

    // 日志文件总开关
    private static Boolean MYLOG_SWITCH = true;
    // 日志写入文件开关
    private static Boolean MYLOG_WRITE_TO_FILE = true;
    // 输出日志级别
    private static int MYLOG_LEVEL = HYConfig.DEBUG ? 4 : 2;
    // 日志文件存放目录
    private static String MYLOG_PATH = "";
    // sd卡中日志文件的最多保存天数
    private static int MYLOG_FILE_SAVE_DAYS = 7;
    // 本类输出的日志文件名称
    private static String MYLOG_FILE_NAME = "treadmill";
    // 日志的输出格式
    private static SimpleDateFormat myLogSdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    private volatile static File sLogfile;
    private static String oldDate;

    private LogUtils() {

    }

    public static void e(String tag, String text) {
        log(tag, text, 'e');
    }

    public static void e(String tag, Throwable tr) {
        log(tag, Log.getStackTraceString(tr), 'e');
    }

    public static void w(String tag, String text) {
        log(tag, text, 'w');
    }

    public static void i(String tag, String text) {
        log(tag, text, 'i');
    }

    public static void d(String tag, String text) {
        log(tag, text, 'd');
    }

    public static void v(String tag, String text) {
        log(tag, text, 'v');
    }

    /**
     * 根据tag, msg和等级，输出日志
     *
     * @return void
     * @since v 1.0
     */
    private static void log(String tag, String msg, char level) {
        if (MYLOG_SWITCH) {
            boolean flag = true;
            if ('e' == level && MYLOG_LEVEL >= LEVEL_ERROR) {
                Log.e(tag, msg);
            } else if ('w' == level && MYLOG_LEVEL >= LEVEL_WARN) {
                Log.w(tag, msg);
            } else if ('i' == level && MYLOG_LEVEL >= LEVEL_INFO) {
                Log.i(tag, msg);
            } else if ('d' == level && MYLOG_LEVEL >= LEVEL_DEBUG) {
                Log.d(tag, msg);
            } else if ('v' == level && MYLOG_LEVEL >= LEVEL_VERBOSE) {
                Log.v(tag, msg);
            } else {
                flag = false;
            }
            if (flag && MYLOG_WRITE_TO_FILE) {
                writeLogToFile(String.valueOf(level), tag, msg);
            }
        }
    }

    public static String initPath() {
        if (TextUtils.isEmpty(MYLOG_PATH)) {
            if (FileUtils.isSDCardAvailable()) {
                MYLOG_PATH = FileUtils.getRootPath() + "/logs";
                File dir = new File(MYLOG_PATH);
                if (!dir.exists()) {
                    dir.mkdirs();
                }
            }
        }
        return MYLOG_PATH;
    }

    /**
     * 打开日志文件并写入日志
     **/
    private static void writeLogToFile(String mylogtype, String tag, String text) {
        String time = myLogSdf.format(Calendar.getInstance().getTime());
        String date = time.substring(0, time.indexOf(" "));
        StringBuffer buffer = new StringBuffer();
        buffer.append(time)
                .append("    ").append(mylogtype)
                .append("    ").append(tag)
                .append("    ").append(text);

        if (sLogfile == null || date != oldDate) {
            synchronized (LogUtils.class) {
                if (sLogfile == null)
                    sLogfile = new File(MYLOG_PATH, MYLOG_FILE_NAME + "_" + date + ".log");
                oldDate = date;
            }
        }

        FileWriter filerWriter = null;
        BufferedWriter bufWriter = null;
        try {
            filerWriter = new FileWriter(sLogfile, true);//true 不进行覆盖
            bufWriter = new BufferedWriter(filerWriter);
            bufWriter.write(buffer.toString());
            bufWriter.newLine();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            IOUtils.close(bufWriter);
            IOUtils.close(filerWriter);
        }
    }

    /**
     * 删除过期的日志文件
     */
    public static void delOutOfDateLogs() {
        long needDeltime = getDateBefore().getTime();
        if (TextUtils.isEmpty(MYLOG_PATH))
            return;
        File[] files = (new File(MYLOG_PATH)).listFiles();
        if (files.length > 0) {
            for (File file : files) {
                long lastModified = file.lastModified();
                if (lastModified < needDeltime) {
                    LogUtils.d(TAG, "===== delOutOfDateLogs：" + file.getPath());
                    file.delete();
            }
            }
        }
    }

    /**
     * 得到现在时间前的几天日期，用来得到需要删除的日志文件名
     */
    private static Date getDateBefore() {
        Date nowtime = new Date();
        Calendar now = Calendar.getInstance();
        now.setTime(nowtime);
        now.set(Calendar.DATE, now.get(Calendar.DATE)
                - MYLOG_FILE_SAVE_DAYS);
        return now.getTime();
    }

}