Android-实现记录“异常闪退“日志

于 2024-05-15 17:19:51 发布
阅读量405 收藏 3
点赞数 3
分类专栏： space 文章标签： android java 日志 Logcat
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43209531/article/details/138915075
版权

1，引文

在开发进程中，因某些未知缘由，应用在运行时异常闪退，然而却无法看到错误日志，着实令人难受。

2，解决思路

借助 Process 来启动一个进程去执行 Logcat 命令，并把内容存储至指定文件内。如此一来，即便应用闪退，依然能够记录下关键信息（进程之间彼此独立）。

3，关键步骤

3.1，启动Logcat进程
Process process = new ProcessBuilder("logcat").redirectErrorStream(true).start();
3.2，读取并保存Process输出内容
try (BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));) {
	FileWritter writter = ...;
	String content;
	while (process.isAlive() && (content = reader.readLine()) != null) {
		writer.write(content);
        writer.write("\n");
        writer.flush();
	}
} ...
3.3，关闭Logcat进程
if (process != null && process.isAlive()) {
	process.destroyForcibly();
}

4，简单封装LoggerUtil工具

import android.app.Activity;
import android.util.Log;

import androidx.annotation.NonNull;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashSet;
import java.util.List;
import java.util.Locale;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicReference;
import java.util.regex.Pattern;

public class LoggerUtil {

    @SuppressWarnings("unused")
    private static final String TAG = "LoggerUtil";

    /**
     * logcat进程对象
     */
    private static final AtomicReference<Process> gProcess = new AtomicReference<>(null);
    /**
     * logcat进程对象的创建器
     */
    private static final ProcessBuilder logcatBuilder = new ProcessBuilder("logcat");

    /**
     * 日志内容过滤器
     */
    private static Set<LogContentFilter> logContentFilters;
    /**
     * 日志目录名
     */
    private static String logDirName;
    /**
     *  日志文件名
     */
    private static String logFileName;
    /**
     * 单个日志文件最大大小
     */
    private static long logFileMaxSize;
    /**
     * 日志文件备份名获取类
     */
    private static BackupLogFileNameGetter backupLogFileNameGetter;

    /**
     * 日志内容过滤器基类
     */
    public interface LogContentFilter {
        /**
         * @param content 日志内容
         * @return true表示记录该内容，false不记录该内容
         */
        boolean isRecord(@NonNull String content);
    }

    /**
     * 日志等级
     */
    public enum Level {
        INFO("I"),
        WARN("W"),
        ERROR("E"),
        DEBUG("D"),
        VERBOSE("V"),
        ALL(".")
        ;
        final String value;
        Level(String value) {
            this.value = value;
        }
        public String getValue() {
            return value;
        }
    }

    /**
     * 默认通过日志等级进行过滤
     */
    public static class DefaultLogContentFilter implements LogContentFilter {
        private final Pattern p;

        public DefaultLogContentFilter(Level level) {
            p = Pattern.compile("^[0-9 -.:]* " + level.getValue() + " .*$");
        }

        @Override
        public boolean isRecord(@NonNull String content) {
            return p.matcher(content).matches();
        }
    }

    /**
     * 日志文件备份名获取基类
     */
    public interface BackupLogFileNameGetter {
        String get(String logFileName);
    }

    /**
     * 默认在当前文件名后面添加当前时间作为备份名
     */
    public static class DefaultBackupLogFileNameGetter implements BackupLogFileNameGetter {
        private final SimpleDateFormat fileDateFormat = new SimpleDateFormat("yyyyMMdd-HHmmss", Locale.ROOT);
        @Override
        public String get(String logFileName) {
            String bakLogFileFormat = "%s_%s.log";
            return String.format(bakLogFileFormat, logFileName, fileDateFormat.format(new Date()));
        }
    }

    /**
     * 参数构造器
     */
    public static class Builder {
        /**
         * 日志内容过滤器
         */
        private final Set<LogContentFilter> logContentFilters = new HashSet<>();
        /**
         * 日志文件夹名字
         */
        private String logDirName = "logs";
        /**
         * 日志文件名
         */
        private String logFileName = "app.log";
        /**
         * 单个日志文件最大大小
         */
        private long logFileMaxSize = 5 * 1024 * 1024; //MB
        /**
         * 日志文件备份名获取类
         */
        private BackupLogFileNameGetter backupLogFileNameGetter = new DefaultBackupLogFileNameGetter();

        public Builder() {
            logContentFilters.add(new DefaultLogContentFilter(Level.WARN));
            logContentFilters.add(new DefaultLogContentFilter(Level.ERROR));
            logContentFilters.add(new DefaultLogContentFilter(Level.DEBUG));
            logContentFilters.add(new DefaultLogContentFilter(Level.VERBOSE));
        }

        public Builder setBackupLogFileNameGetter(BackupLogFileNameGetter backupLogFileNameGetter) {
            if (backupLogFileNameGetter == null) return this;
            this.backupLogFileNameGetter = backupLogFileNameGetter;
            return this;
        }

        public Builder setLogFileName(String logFileName) {
            if (logFileName == null || logFileName.trim().isEmpty()) return this;
            this.logFileName = logFileName;
            return this;
        }

        public Builder setLogDirName(String logDirName) {
            if (logDirName == null || logDirName.trim().isEmpty()) return this;
            this.logDirName = logDirName;
            return this;
        }

        /**
         * 单位"B"，最小为512KB <br/>
         * 1MB = 1024KB <br/>
         * 1KB = 1024B
         */
        public Builder setLogFileMaxSize(long logFileMaxSize) {
            if (logFileMaxSize < 512 * 1024) return this;
            this.logFileMaxSize = logFileMaxSize;
            return this;
        }

        public Builder addLogContentFilter(LogContentFilter logContentFilter) {
            if (logContentFilter == null) return this;
            logContentFilters.add(logContentFilter);
            return this;
        }

        public Builder addLogContentFilters(List<LogContentFilter> logContentFilters) {
            if (logContentFilters == null || logContentFilters.isEmpty()) return this;
            this.logContentFilters.addAll(logContentFilters);
            return this;
        }

        public Builder setLogContentFilter(LogContentFilter logContentFilter) {
            logContentFilters.clear();
            return addLogContentFilter(logContentFilter);
        }

        public Builder setLogContentFilters(List<LogContentFilter> logContentFilters) {
            this.logContentFilters.clear();
            return addLogContentFilters(logContentFilters);
        }
    }

    public static void start(Activity activity) {
        start(activity, null);
    }

    public static void start(Activity activity, Builder builder) {
        bind(builder);
        synchronized (gProcess) {
            stop();
            try {
                gProcess.set(logcatBuilder.redirectErrorStream(true).start());
            } catch (Exception e) {
                Log.e(TAG, "开启Logcat失败", e);
                return;
            }
        }

        final File logRootDir = activity.getExternalFilesDir(null);
        if (logRootDir == null) {
            stop();
            Log.e(TAG, "getExternalFilesDir获取失败");
            return;
        }
        CompletableFuture.runAsync(() -> {
            File logFile = getLogFile(logRootDir);
            if (logFile == null) {
                stop();
                return;
            }
            Process process = gProcess.get();
            FileWriter writer = null;
            try (BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));) {
                writer = new FileWriter(logFile, true);
                String content;
                while (process.isAlive() && (content = reader.readLine()) != null) {
                    if (content.trim().length() == 0 || logContentFilters.isEmpty()) continue;
                    boolean needRecord = true;
                    for (LogContentFilter logFilter : logContentFilters) {
                        if (!logFilter.isRecord(content)) {
                            needRecord = false;
                            break;
                        }
                    }
                    if (!needRecord) continue;

                    writer.write(content);
                    writer.write("\n");
                    writer.flush();

                    if (logFile.length() >= logFileMaxSize) {
                        logFile = getLogFile(logRootDir);
                        if (logFile == null) {
                            stop();
                            return;
                        }
                        writer.close();
                        writer = new FileWriter(getLogFile(logRootDir), true);
                    }
                }
            } catch (Exception ignored) {
            } finally {
                stop();
                if (writer != null) {
                    try {
                        writer.close();
                    } catch (IOException ignored) {
                    }
                }
            }
        }, Executors.newSingleThreadExecutor());
    }

    /**
     * 绑定Builder数据
     */
    private static void bind(Builder builder) {
        if (builder == null) {
            builder = new Builder();
        }
        logContentFilters = builder.logContentFilters;
        logDirName = builder.logDirName;
        logFileName = builder.logFileName;
        logFileMaxSize = builder.logFileMaxSize;
        backupLogFileNameGetter = builder.backupLogFileNameGetter;
    }

    private static File getLogFile(@NonNull File logRootDir) {
        File logDir = new File(logRootDir, logDirName);
        if (!logDir.exists() && !logDir.mkdirs()) {
            Log.e(TAG, "创建日志文件目录失败");
            return null;
        }
        File logFile = new File(logDir, logFileName);
        try {
            if (!logFile.exists() && !logFile.createNewFile()) {
                Log.e(TAG, "创建日志文件失败");
                return null;
            }
        } catch (IOException e) {
            Log.e(TAG, "创建日志文件失败", e);
            return null;
        }
        long fileSize = logFile.length();
        if (fileSize >= logFileMaxSize) {
            File bakFile = new File(logDir, backupLogFileNameGetter.get(logFileName));
            if (logFile.renameTo(bakFile)) {
                Log.e(TAG, "重命名日志文件失败");
                return null;
            }
            logFile = new File(logDir, logFileName);
        }

        return logFile;
    }

    public static void stop() {
        synchronized (gProcess) {
            Process process = gProcess.get();
            if (process != null && process.isAlive()) {
                process.destroyForcibly();
            }
            gProcess.set(null);
        }
    }
}
_Mr.Tree
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android闪退前处理,Android中处理崩溃异常和分析日志的两种思路
weixin_42362146的博客
05-31 571
前言：在Android开发app中，想要及时了解线上app的运行情况，须要采集样本日志，也就是常说的log,今天由“懂你行云”授权本公众号独家发布，分享他的《处理崩溃异常和分析日志的两种思路》，懂你行云的blog链接为：http://blog.csdn.net/zhangteng22。下方阅读原文可看他的原文。正文如下：我们写程序的时候都希望能写出一个没有任何Bug的程序，期望在任何情况下都不会发...
Android中程序闪退看不到报错日志？
m0_45144867的博客
09-08 2193
解决方法：将报错日志拿出，保存到手机 1、在项目中添加名为CrashHandler的类，该类代码如下： package com.example.myapplication; import android.content.Context; import android.content.pm.PackageInfo; import android.content.pm.PackageManager; import android.os.Build; import android.os.Environment;
Android 捕获全局异常，防止异常闪退，记录异常日志
weixin_55522643的博客
09-15 1463
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.widget.Toast.
Android 报错，闪退（错误）日志保存到手机内存中，以文本文件的形式保存
qq_36570506的博客
07-12 2129
Android 报错，闪退（错误）日志保存到手机内存中，以文本文件的形式保存
android闪退日志收集
weixin_33951761的博客
04-19 482
写一个工具类，然后直接引用，简单粗暴。 package com.socialsecurity.main.exception; import java.io.File; import java.io.FileOutputStream; import java.io.PrintWriter; import java.io.StringWriter; import java.io.W...
Android 查看闪退日志
热门推荐
kuangben2000的博客
05-03 2万+
Android 查看闪退日志 (1) APP闪退分析及Crash日志获取 https://blog.csdn.net/hairubb/article/details/78210824 app 闪退一般抓取mtklog看不出具体原因，即使有aee_exp文件夹产生，使用Logcatview工具也解析不出 具体的db文件 一、手机crash之后，如果弹出的“应用程序意外停止”的提示如果没有消失...
android应用闪退日志,APP闪退，日志如下：
weixin_32328999的博客
06-02 1036
APP闪退，看提示这大致的意思是内存不够？应该怎么解决？百度查了下有文章说在manifest.xml中添加一个属性：android:largeHeap="true"，这个manifest.xml在哪里？应该怎么加？日志如下：BOARD:rk30sdkBOOTLOADER:unknownBRAND:AndroidCPU_ABI:armeabi-v7aCPU_ABI2:armeabiDEVICE:rk...
android 程序闪退 log,应用闪退log日志。。
weixin_39566593的博客
05-26 712
应用闪退log日志。。12-04 14:04:24.121 19876 19876 E AndroidRuntime FATAL EXCEPTION: main12-04 14:04:24.121 19876 19876 E AndroidRuntime Process:...
安装android-86之后安装APP闪退的解决办法，亲测可用
05-14
解决了网络问题，就是安装软件后打开就闪退的问题了，这个解决办法亲测可用，大家可以试一下，就三四步，很简单。
Android-Cloglogger实现标准的Android日志
08-13
Clog logger实现标准的Android日志
Android代码-Android手机端崩溃日志记录。
08-06
SpiderMan SpiderMan能为您做的： Debug环境可以在手机上显示崩溃信息，分享给相关开发人员~ 再也不用担心测试妹妹给你重现怎么操作崩溃的啦！ 再也不用担心产品相关人员给你说哪儿哪儿崩溃，但是又重现不了的尴尬啦！ 再也不用担心某些Rom禁止异常输出啦！ 再也不用担心开发工具log信息时灵时不灵啦 Debug环境 Share 引入依赖 debugImplementation 'com.simple:spiderman:1.0.8' releaseImplementation 'com.simple:spiderman-no-op:1.0.8' 初始化 > 放到Application的`onCreate()初始化中，因为static了传入的context，并且放在其他Library初始化的前面 public class App extends Application { @Override public void onCreate() { super.onCreate(); //放在其他库初
Android-使用Kotlin和Timber轻松实现Android日志记录
08-13
使用Kotlin和Timber轻松实现Android日志记录
android 捕获系统异常并上传日志具体实现
09-05
介绍了android 捕获系统异常并上传日志具体实现，有需要的朋友可以参考一下
Android实现多次闪退清除数据
09-02
主要介绍了Android实现多次闪退清除数据的相关资料，感兴趣的小伙伴们可以参考一下
Android&iOS闪退日志获取
a653202的博客
01-17 7285
app崩溃日志获取
android 添加闪退日志,求助，简单UI界面，调试总是闪退，还没有LOG错误日志？？？...
weixin_34323587的博客
05-29 117
该楼层疑似违规已被系统折叠隐藏此楼查看此楼折腾了快一天了，还不知道哪里出错了package com.example.love;import java.text.ParseException;import java.text.SimpleDateFormat;import java.util.Calendar;import java.util.Date;import android.R.integ...
Android开发adb命令和闪退日志
夏夏的博客
03-13 2895
Android Debug Bridge，是 Android 开发/测试人员的强大工具，也是 Android 设备玩家的好玩具。安卓调试桥 (Android Debug Bridge, adb)，是一种可用来操作手机设备或模拟器的命令行工具。它存在于 sdk/platform-tools 目录下。现在 Android Studio 已经将大部分 ADB 命令以图形化的形式实现了。
Android 代替 try catch处理崩溃闪退错误并日志存储到SD卡
最新发布
东北大汉的博客
08-04 294
当Android应用程序出现未捕获的异常，都会弹出一个强制退出的弹框，在这种情况下，用户体验非常差。且发布到线上后，开发没法定位Bug的位置，这就需要一个能全局捕获异常，并且将这个异常log上传到服务器的功能。1.内存溢出导致崩溃2.未处理的异常（堆栈溢出、空指针赋值、栈数组越界、程序抛出的异常）3.组件未注册，资源未找到4.使用application的context和'组件的context不当5.网络和io过程中抛出的异常，try catch没有捕捉到。
android app全局捕获异常 避免闪退
07-12
在Android应用中，可以通过全局捕获异常来避免应用闪退。可以通过以下步骤实现： 1. 创建一个自定义的Application类，并在其中重写`Thread.UncaughtExceptionHandler`接口的`uncaughtException`方法。 2. 在`uncaughtException`方法中处理全局异常，例如记录异常信息、上传日志或者进行其他处理操作。 3. 在Application的onCreate方法中，将自定义的UncaughtExceptionHandler设置为默认的异常处理器。 下面是一个示例代码： ```java public class MyApplication extends Application implements Thread.UncaughtExceptionHandler { @Override public void onCreate() { super.onCreate(); // 设置全局异常处理器 Thread.setDefaultUncaughtExceptionHandler(this); } @Override public void uncaughtException(Thread thread, Throwable ex) { // 处理全局异常，例如记录异常信息、上传日志等操作 Log.e("MyApplication", "Uncaught Exception: " + ex.getMessage()); // 重启应用或者执行其他操作 restartApp(); } private void restartApp() { // 重启应用，可以根据实际需求来实现 Intent intent = new Intent(getApplicationContext(), MainActivity.class); intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK); PendingIntent pendingIntent = PendingIntent.getActivity(getApplicationContext(), 0, intent, PendingIntent.FLAG_ONE_SHOT); AlarmManager alarmManager = (AlarmManager) getSystemService(Context.ALARM_SERVICE); alarmManager.set(AlarmManager.RTC, System.currentTimeMillis() + 1000, pendingIntent); // 退出应用 System.exit(0); } } ``` 记得在AndroidManifest.xml文件中将自定义的Application类配置为应用的默认Application类： ```xml <application android:name=".MyApplication" ...> ... </application> ``` 通过以上步骤，当应用发生未捕获的异常时，会调用自定义的异常处理方法，你可以在其中进行相应的处理操作，例如记录异常信息、上传日志等。最后，你可以选择重启应用或者执行其他操作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值