Leia o logcat programaticamente dentro do aplicativo

116

Quero ler e reagir aos logs do logcat em meu aplicativo.

Encontrei o seguinte código:

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

Este código realmente retorna os logs do logcat feitos até que o aplicativo fosse iniciado -

Mas é possível ouvir continuamente até mesmo novos logs do logcat?

David
fonte
1
A opção -d irá despejar o log e sair. Apenas remova a opção -d e o logcat não sairá.
Frohnzie,
1
Como posso limpar isso? - Preciso encontrar uma linha específica em relação à minha inscrição
David,
1
Nenhuma raiz necessária.
Luis
2
Se a raiz não for necessária, apenas a construção de desenvolvimento pode acessar seu próprio log? E onde exatamente esse código é executado? com no aplicativo apk?
Ayyappa
2
Tentei um teste. Eu só conseguia ler os eventos do meu próprio processo. Acho que você precisa do root para ler outros eventos de processos.
Yetti99

Respostas:

55

Você pode continuar lendo os logs, apenas removendo o sinalizador "-d" em seu código acima.

O sinalizador "-d" instrui o logcat para mostrar o conteúdo do log e sair. Se você remover o sinalizador, o logcat não será encerrado e continuará enviando qualquer nova linha adicionada a ele.

Apenas tenha em mente que isso pode bloquear seu aplicativo se não for projetado corretamente.

boa sorte.

Luis
fonte
Se eu remover o "-d", o aplicativo travará e aparecerá a caixa de diálogo forçar o fechamento.
David,
21
Como eu disse acima, seria necessário um design de aplicativo cuidadoso. Você precisa ter o código acima em execução em um thread separado (para evitar o bloqueio da IU) e, como deseja atualizar o textview na IU com informações de log, você precisa usar um Handler para postar as informações de volta na IU.
Luis
2
Olá, Luis, por favor, você pode postar um exemplo de código de um tópico separado?
img.simone
Consulte a resposta stackoverflow.com/a/59511458/1185087, pois está usando corrotinas que não bloqueiam o thread de interface do usuário.
user1185087
8

Você pode limpar seu logcat com este método que estou usando para limpar depois de gravar o logcat em um arquivo para evitar linhas duplicadas:

public void clearLog(){
     try {
         Process process = new ProcessBuilder()
         .command("logcat", "-c")
         .redirectErrorStream(true)
         .start();
    } catch (IOException e) {
    }
}
Jan Ziesse
fonte
Acabei de descobrir que limpar o log pode levar algum tempo. Portanto, se você limpar o registro e, em seguida, lê-lo imediatamente, algumas entradas antigas podem ainda não ter sido limpas. Além disso, algumas entradas de log recém-adicionadas podem ser excluídas porque foram adicionadas antes da conclusão da limpeza. Não faz diferença, mesmo se você chamar process.waitfor ().
Tom Rutchik
6

Com co-rotinas e as bibliotecas oficiais lifecycle-livesata-ktx e lifecycle-viewmodel-ktx , é simples assim:

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

Uso

val logCatViewModel by viewModels<LogCatViewModel>()

logCatViewModel.logCatOutput().observe(this, Observer{ logMessage ->
    logMessageTextView.append("$logMessage\n")
})
user1185087
fonte
Ótima sugestão. Eu me pergunto se existe uma maneira de fazer isso funcionar com em WebViewvez de TextView.
Fatih
4

Aqui está um rápido conjunto / drop-in que pode ser usado para capturar todos os itens de log atuais ou novos (desde a última solicitação).

Você deve modificar / estender isso, porque você pode querer retornar um fluxo contínuo em vez de um LogCapture.

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

}

Em seu projeto que realiza o registro de atividades:

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

Quando você quiser capturar tudo que você logou através do "Logger"

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

Quando você fica com fome e quer comer mais lenha

LogCapture nextCapture = capture.getNextCapture();

Você pode obter a captura como uma string com

String captureString = capture.toString();

Ou você pode obter os itens de registro da captura com

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

Não existe um método estático exato para capturar as chaves de log estrangeiras, mas há uma maneira, no entanto

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

Usar o acima também permitirá que você chame Logger.this.nextCapturea captura estrangeira.

Hypersoft Systems
fonte
Geralmente, esse é o melhor método para realizar o registro e a análise devido à estratégia de baixa sobrecarga [no processamento]. Pode ou não haver um bug neste código. O tratamento logcat da seleção de tempo deve ser maior do que o tempo dado para uma correspondência correta. A falta de um algoritmo de seleção de tempo correto criará uma entrada de log duplicada no primeiro elemento de nextCapture.
Hypersoft Systems
A falta de documentação sobre formatos de hora e localidades associadas à opção do seletor de hora do android-logcat pode ter criado bugs que exigirão modificações de interpolação de formato de hora.
Hypersoft Systems
Oi .. Usei seu código, mas o resultado está sempre vazio. Ainda é válido?
img.simone
@ img.simone; Eu atualizei isso com minhas revisões de código. O logcat do Android está quebrado de algumas maneiras. A primeira é que a saída do formato de data do logcat não tem componente de ano, o que torna a comparação de data fallback para o ano 1970; em segundo lugar, a opção -t e -T com uma data não começa a exibir os logs na data especificada, então temos que analisar a data e compará-la com uma data numérica sincronizada com o ano de 1970. Não posso testar isso atualização para você, mas definitivamente deve funcionar; como o código vem de um repositório de trabalho com alterações específicas para este contexto.
Hypersoft Systems
1
Você pode encontrar o código de trabalho aqui em git.hsusa.core.log.controller.AndroidLogController.java; Você pode querer usar minha biblioteca hscore em vez desta solução "rápida e suja". Para fazer o registro com hscore você usaria: public final static SmartLogContext log = SmartLog.getContextFor("MyLogContext");para começar. Funciona da mesma forma com uma API melhor. Você pode usar meu rastreador de problemas do hub git se precisar de ALGUMA ajuda com isso.
Hypersoft Systems
3

O sinalizador "-c" limpa o buffer.

-c Limpa (limpa) todo o log e sai.

Allen
fonte
como usar -c no código acima. se encontrar algo no log, quero limpar
yuva ツ
yuva, basta fazer: process = Runtime.getRuntime (). exec ("logcat -c"); bufferedReader = novo BufferedReader (novo InputStreamReader (process.getInputStream ()), 1024); linha = bufferedReader.readLine ();
djdance
1
            //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"))
              {
              }
            }

Estou usando isso no meu aplicativo e funciona. E você pode usar o código acima em Timer Task para que não pare o seu thread principal

        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);
      }
Reetpreet Brar
fonte