在应用程序中以编程方式读取 logcat

我想读取应用程序中的 logcat 日志并对其作出反应。

我找到了以下代码:

try {
Process process = Runtime.getRuntime().exec("logcat -d");
BufferedReader bufferedReader = new BufferedReader(
new InputStreamReader(process.getInputStream()));


StringBuilder log=new StringBuilder();
String line = "";
while ((line = bufferedReader.readLine()) != null) {
log.append(line);
}
TextView tv = (TextView)findViewById(R.id.textView1);
tv.setText(log.toString());
}
catch (IOException e) {}

此代码确实返回应用程序启动之前的 logcat 日志-

但是，是否有可能连续监听甚至是新的 logcat 日志？

91247 次浏览
小开

您可以通过删除上面代码中的“-d”标志来继续读取日志。

“-d”标志指示 logcat 显示日志内容并退出。如果删除了标志，logcat 将不会终止，并继续发送添加到其中的任何新行。

请记住，如果设计不正确，这可能会阻止您的应用程序。

祝你好运。

小开

“-c”标志清除缓冲区。

- c 清除(冲洗)整个日志和出口。

小开

你可以用这个方法来清除你的 logcat，我正在用这个方法在把 logcat 写入文件后清除，以避免重复行:

public void clearLog(){
try {
Process process = new ProcessBuilder()
.command("logcat", "-c")
.redirectErrorStream(true)
.start();
} catch (IOException e) {
}
}
小开 
            //CLEAR LOGS
Runtime.getRuntime().exec("logcat -c");
//LISTEN TO NEW LOGS
Process pq=Runtime.getRuntime().exec("logcat v main");
BufferedReader brq = new BufferedReader(new InputStreamReader(pq.getInputStream()));
String sq="";
while ((sq = brq.readLine()) != null)
{
//CHECK YOUR MSG HERE
if(sq.contains("send MMS with param"))
{
}
}

我在我的应用程序中使用它，它工作。 您可以在 Timer Task 中使用上面的代码，这样它就不会停止您的主线程

        Timer t;
this.t.schedule(new TimerTask()
{
public void run()
{
try
{
ReadMessageResponse.this.startRecord();//ABOVE METHOD HERE


}
catch (IOException ex)
{
//NEED TO CHECK SOME VARIABLE TO STOP MONITORING LOGS
System.err.println("Record Stopped");
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
finally
{
ReadMessageResponse.this.t.cancel();
}
}
}, 0L);
}
小开

下面是一个快速的组合/下拉文件，可用于捕获所有当前日志项或所有新(自上次请求以来)日志项。

您应该修改/扩展它，因为您可能希望返回连续流，而不是 LogCapture。

Android LogCat“手册”: https://developer.android.com/studio/command-line/logcat.html

import android.util.Log;


import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import java.util.Stack;


/**
* Created by triston on 6/30/17.
*/


public class Logger {


// http://www.java2s.com/Tutorial/Java/0040__Data-Type/SimpleDateFormat.htm
private static final String ANDROID_LOG_TIME_FORMAT = "MM-dd kk:mm:ss.SSS";
private static SimpleDateFormat logCatDate = new SimpleDateFormat(ANDROID_LOG_TIME_FORMAT);


public static String lineEnding = "\n";
private final String logKey;


private static List<String> logKeys = new ArrayList<String>();


Logger(String tag) {
logKey = tag;
if (! logKeys.contains(tag)) logKeys.add(logKey);
}


public static class LogCapture {
private String lastLogTime = null;
public final String buffer;
public final List<String> log, keys;
LogCapture(String oLogBuffer, List<String>oLogKeys) {
this.buffer = oLogBuffer;
this.keys = oLogKeys;
this.log = new ArrayList<>();
}
private void close() {
if (isEmpty()) return;
String[] out = log.get(log.size() - 1).split(" ");
lastLogTime = (out[0]+" "+out[1]);
}
private boolean isEmpty() {
return log.size() == 0;
}
public LogCapture getNextCapture() {
LogCapture capture = getLogCat(buffer, lastLogTime, keys);
if (capture == null || capture.isEmpty()) return null;
return capture;
}
public String toString() {
StringBuilder output = new StringBuilder();
for (String data : log) {
output.append(data+lineEnding);
}
return output.toString();
}
}


/**
* Get a list of the known log keys
* @return copy only
*/
public static List<String> getLogKeys() {
return logKeys.subList(0, logKeys.size() - 1);
}


/**
* Platform: Android
* Get the logcat output in time format from a buffer for this set of static logKeys.
* @param oLogBuffer logcat buffer ring
* @return A log capture which can be used to make further captures.
*/
public static LogCapture getLogCat(String oLogBuffer) { return getLogCat(oLogBuffer, null, getLogKeys()); }


/**
* Platform: Android
* Get the logcat output in time format from a buffer for a set of log-keys; since a specified time.
* @param oLogBuffer logcat buffer ring
* @param oLogTime time at which to start capturing log data, or null for all data
* @param oLogKeys logcat tags to capture
* @return A log capture; which can be used to make further captures.
*/
public static LogCapture getLogCat(String oLogBuffer, String oLogTime, List<String> oLogKeys) {
try {


List<String>sCommand = new ArrayList<String>();
sCommand.add("logcat");
sCommand.add("-bmain");
sCommand.add("-vtime");
sCommand.add("-s");
sCommand.add("-d");


sCommand.add("-T"+oLogTime);


for (String item : oLogKeys) sCommand.add(item+":V"); // log level: ALL
sCommand.add("*:S"); // ignore logs which are not selected


Process process = new ProcessBuilder().command(sCommand).start();


BufferedReader bufferedReader = new BufferedReader(
new InputStreamReader(process.getInputStream()));


LogCapture mLogCapture = new LogCapture(oLogBuffer, oLogKeys);
String line = "";


long lLogTime = logCatDate.parse(oLogTime).getTime();
if (lLogTime > 0) {
// Synchronize with "NO YEAR CLOCK" @ unix epoch-year: 1970
Calendar calendar = Calendar.getInstance();
calendar.setTime(new Date(oLogTime));
calendar.set(Calendar.YEAR, 1970);
Date calDate = calendar.getTime();
lLogTime = calDate.getTime();
}


while ((line = bufferedReader.readLine()) != null) {
long when = logCatDate.parse(line).getTime();
if (when > lLogTime) {
mLogCapture.log.add(line);
break; // stop checking for date matching
}
}


// continue collecting
while ((line = bufferedReader.readLine()) != null) mLogCapture.log.add(line);


mLogCapture.close();
return mLogCapture;
} catch (Exception e) {
// since this is a log reader, there is nowhere to go and nothing useful to do
return null;
}
}


/**
* "Error"
* @param e
*/
public void failure(Exception e) {
Log.e(logKey, Log.getStackTraceString(e));
}


/**
* "Error"
* @param message
* @param e
*/
public void failure(String message, Exception e) {
Log.e(logKey, message, e);
}


public void warning(String message) {
Log.w(logKey, message);
}


public void warning(String message, Exception e) {
Log.w(logKey, message, e);
}


/**
* "Information"
* @param message
*/
public void message(String message) {
Log.i(logKey, message);
}


/**
* "Debug"
* @param message a Message
*/
public void examination(String message) {
Log.d(logKey, message);
}


/**
* "Debug"
* @param message a Message
* @param e An failure
*/
public void examination(String message, Exception e) {
Log.d(logKey, message, e);
}


}

在执行活动日志记录的项目中:

Logger log = new Logger("SuperLog");
// perform logging methods

当你想要捕获你通过“日志记录器”记录的所有内容时

LogCapture capture = Logger.getLogCat("main");

当你饿了，想吃更多的木头时

LogCapture nextCapture = capture.getNextCapture();

可以将捕获作为字符串获取

String captureString = capture.toString();

或者您可以使用

String logItem = capture.log.get(itemNumber);

没有精确的静态方法来捕获外部日志键，但是仍然有一种方法

LogCapture foreignCapture = Logger.getLogCat("main", null, foreignCaptureKeyList);

使用上面的命令还将允许您在外部捕获时调用 Logger.this.nextCapture。

小开

使用协程和官方的 生命周期-实时数据-ktx和 生命周期-视图模型-ktx库，就像这样简单:

class LogCatViewModel : ViewModel() {
fun logCatOutput() = liveData(viewModelScope.coroutineContext + Dispatchers.IO) {
Runtime.getRuntime().exec("logcat -c")
Runtime.getRuntime().exec("logcat")
.inputStream
.bufferedReader()
.useLines { lines -> lines.forEach { line -> emit(line) }
}
}
}

用法

val logCatViewModel by viewModels<LogCatViewModel>()


logCatViewModel.logCatOutput().observe(this, Observer{ logMessage ->
logMessageTextView.append("$logMessage\n")
})
小开

基于@user1185087的回答，一个没有 ViewModel 的简单解决方案可以是:

在 IO 线程上启动作业:

// Custom scope for collecting logs on IO threads.
val scope = CoroutineScope(Job() + Dispatchers.IO)


val job = scope.launch {
Runtime.getRuntime().exec("logcat -c") // Clear logs
Runtime.getRuntime().exec("logcat") // Start to capture new logs
.inputStream
.bufferedReader()
.useLines { lines ->
// Note that this forEach loop is an infinite loop until this job is cancelled.
lines.forEach { newLine ->
// Check whether this job is cancelled, since a coroutine must
// cooperate to be cancellable.
ensureActive()
// TODO: Write newLine into a file or buffer or anywhere appropriate
}
}
}

从主线程中取消作业:

MainScope().launch {
// Cancel the job and wait for its completion on main thread.
job.cancelAndJoin()
job = null // May be necessary
// TODO: Anything else you may want to clean up
}

如果您想在后台线程上连续收集应用程序的新日志，这个解决方案应该足够了。

小开

尝试将此权限添加到主节点:

<uses-permission android:name="android.permission.READ_LOGS"/>

提交答案