Read logcat programmatically within application

Question

I want to read and react to logcat logs within my application.

I found the following code:

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) {}

This code indeed returns the logcat logs that made until the application was started -

But is it possible to continuously listen to even new logcat logs?

• Frohnzie: The -d option will dump the log and exit. Just remove the -d option and logcat will not exit.
• David: How can I clear it? - I need to find a specific line regarding my application
• Luis: No root required.
• Ayyappa: If root is not required, only the development build can access its own log? And where exactly this code is executed? with in the apk application?
• Yetti99: I tried a test. I was only able to read my own process's events. I think you need root to read other processes events.

Answer 1

You can keep reading the logs, just by removing the "-d" flag in your code above.

The "-d" flag instruct to logcat to show log content and exit. If you remove the flag, logcat will not terminate and keeps sending any new line added to it.

Just have in mind that this may block your application if not correctly designed.

good luck.

• David: If I remove the "-d" the application stucked and I'm getting the force closed dialog.
• Luis: As I said above, it would required a carefull application design. You need to have the above code running in a separate thread (to avoid blocking the UI), and as you want to update the textview in the UI with log information, you need to use a Handler to post the information back to UI.
• img.simone: Hi Luis, please can you post an example code of a separated thread?
• user1185087: See answer stackoverflow.com/a/59511458/1185087 it's using coroutines which don't block the UI thread.

Answer 2

With coroutines and the official lifecycle-livedata-ktx and lifecycle-viewmodel-ktx libraries it's simple like that:

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) }
 }
 }
}

Usage

val logCatViewModel by viewModels<LogCatViewModel>()
logCatViewModel.logCatOutput().observe(this, Observer{ logMessage ->
 logMessageTextView.append("$logMessage\n")
})

• Fatih: Great suggestion. I wonder if there is a way to make this work with WebView instead of TextView.
• Arsenius: But why I cannot access logcat of another application? Runtime.getRuntime().exec("logcat some.other.app")
• FEBRYAN ASA PERDANA: @Arsenius what is the version of Android OS in your device? Starting from Android5/6/7 and higher you can not read info about other apps, including its status and logs. So there's absolutely no way to do that...................... unless you're rooted.
• DeXter: @EyalElbaz I believe this answer is on nonUI thread. liveData(viewModelScope.coroutineContext + Dispatchers.IO) makes the logcat codes work on a subthread for IO operations using Coroutines in Kotlin.
• Tom Raganowicz: I am wondering is there any way to filter by log verbosity?

Answer 3

You can clear your logcat with this method i'm using to clear after writing logcat to a file to avoid duplicated lines:

public void clearLog(){
 try {
 Process process = new ProcessBuilder()
 .command("logcat", "-c")
 .redirectErrorStream(true)
 .start();
 } catch (IOException e) {
 }
}

• Tom Rutchik: I just discovered that clearing the log can take some time. So if you clear the log and then read the log immediate, some old entries may not yet been cleared. In addition, some newly added log entries can be deleted as because they get added before the clear completes. It doesn't make a difference even if you call process.waitfor().

Answer 4

Based on @user1185087's answer, a simple solution without ViewModel could be:

Start the job on an IO thread:

// 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 
 }
 }
}

Cancel the job from the main thread:

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
}

This solution should suffice if you want to collect your app's new logs continuously on a background thread.

Answer 5

Here is a quick put-together/drop-in that can be used for capturing all current, or all new (since a last request) log items.

You should modify/extend this, because you might want to return a continuous-stream rather than a LogCapture.

The Android LogCat "Manual": 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);
 }
}

In your project which performs activity logging:

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

When you want to capture everything you logged through "Logger"

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

When you get hungry and you want to snack on more logs

LogCapture nextCapture = capture.getNextCapture();

You can get the capture as a string with

String captureString = capture.toString();

Or you can get the log items of the capture with

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

There is no exact static method to capture foreign log keys but there is a way none the less

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

Using the above will also permit you to call Logger.this.nextCapture on the foreign capture.

• Hypersoft Systems: This is generally the best method to perform logging and analysis due to the low-overhead[in processing] strategy. There may or may not be a bug in this code. logcat treatment of time selection must be greater than time given for a correct match. Lack of a correct time selection algorithm will create a duplicate log entry at the first element of nextCapture.
• Hypersoft Systems: The lack of documentation on time formats and locales associated with android-logcat's time selector option may have created bugs which will require time-format-interpolation-modifications.
• img.simone: Hi.. I used your code but the result is always empty. Is still valid?
• Hypersoft Systems: @img.simone; I have updated this with my code revisions. Android's logcat is broken in a few ways. The first, is that the date format output of logcat has no year component, which makes a date comparison fallback to the year 1970; secondly the -t and -T option with a date doesn't actually start spitting out logs at the date specified, so we have to parse the date and compare it with a numeric date synchronized to the year 1970. I can't test this update for you, but it should definitely work; as the code comes from a working repository with amendments specific to this context.
• Hypersoft Systems: You can find the working code here under git.hsusa.core.log.controller.AndroidLogController.java; You may wish to use my hscore library instead of this "quick & dirty" solution. To do logging with hscore you would use: public final static SmartLogContext log = SmartLog.getContextFor("MyLogContext"); to get started. It works pretty much the same way with a better API. You can use my git hub issue tracker if you need ANY help with that.

Answer 6

The "-c" flag clears the buffer.

-c Clears (flushes) the entire log and exits.

• yuva ツ: how to use -c in above code.if found something in log i want to clear it
• djdance: yuva, just do: process = Runtime.getRuntime().exec("logcat -c"); bufferedReader = new BufferedReader( new InputStreamReader(process.getInputStream()), 1024); line = bufferedReader.readLine()

Answer 7

 //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"))
 {
 }
 }

I am using this in my app and it works . And you can use above code in Timer Task so that it wont stop your main thread

 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);
 }