strumienia wyjściowego android logcat na karcie SD

Question

chcę osiągnąć następujące ale do tej pory nie ma szczęścia

• Otwórz plik na karcie SD przy pierwszym uruchomieniu aplikacji android.
• Strumień wyjściowy logcat do pliku.
• Po zamknięciu aplikacji zatrzymaj przesyłanie strumieniowe logcat.

W moim ApplicationClass rozciąga metody nakładania onCreate(), robię to

wwLogManager.openLogFile(); 

i oto kod w openLogFile()

 private static final String LOGCAT_COMMAND = "logcat -v time -f "; 
     String timestamp = Long.toString(System.currentTimeMillis()); 
     String logFileName = BuildConstants.LOG_LOCATION + "_" + timestamp + ".log";      
     mLogFile = new File(Environment.getExternalStorageDirectory() + logFileName); 
     mLogFile.createNewFile(); 
     String cmd = LOGCAT_COMMAND + mLogFile.getAbsolutePath(); 
     Runtime.getRuntime().exec(cmd); 

zrobić uzyskać pliki dziennika w sd karta, ale dane wyjściowe dziennika w tych plikach nie mają żadnego śladu wywołań Log.i(), które umieściłem w moich działaniach. Czy użyte tutaj polecenie logcat jest poprawne? Dzięki!

Answer 1

Spróbuj ręczne ustawienie filtru jak opisano tutaj: http://developer.android.com/guide/developing/debugging/debugging-log.html#filteringOutput

Coś jak:

logcat ActivityManager:I MyApp:V *:S 

Jeśli zastąpić „MojaApl” ze znacznikami dziennika, którego używasz, które powinny pokazać Ci wszystkie informacje (i większe) logi z ActivityManager i wszystkie szczegółowe (i większe) logi z twojej aplikacji.

Answer 2

Przepraszam, jeśli nie rozumiem twoich celów, ale może powinieneś użyć java.util.logging API zamiast używać Logcata lub mechanizmu logowania Android.

Podobnie jak Android rejestrowania API The java.util.logging API pozwala łatwo rejestrować komunikaty na różnych poziomach, takich jak grzywny, lepszej ostrzegają, ciężkie, itp

Ale średnia rejestrowania API ma dodatkowe zalety, too. Na przykład można łatwo utworzyć plik dziennika plik za pomocą FileHandler. W rzeczywistości FileHandler ma wbudowany mechanizm rotacji logów, więc nie musisz się martwić (tak bardzo) o czyszczenie plików dziennika. Można również utworzyć hierarchię Logger s; więc, na przykład, jeśli masz dwa Logger s, com.example.foo i com.example.foo.bar, zmiana poziomu rejestrowania pierwszego zmieni również poziom rejestrowania tego ostatniego. To zadziała nawet, jeśli dwa Logger s zostaną utworzone w różnych klasach! Co więcej, zmieniasz zachowanie rejestrowania w środowisku wykonawczym, określając plik konfiguracyjny rejestrowania. Na koniec możesz dostosować format dziennika, wprowadzając własny kod Formatter (lub po prostu użyj SimpleFormatter, aby uniknąć domyślnego formatu XML).

Aby użyć standardowego logowania API, możesz spróbować czegoś takiego:

// Logger logger is an instance variable 
    // FileHandler logHandler is an instance variable 

    try { 
     String logDirectory = 
      Environment.getExternalStorageDirectory() + "/log_directory"; 

     // the %g is the number of the current log in the rotation 
     String logFileName = logDirectory + "/logfile_base_name_%g.log"; 

     // ... 
     // make sure that the log directory exists, or the next command will fail 
     // 

     // create a log file at the specified location that is capped 100kB. Keep up to 5 logs. 
     logHandler = new FileHandler(logFileName, 100 * 1024, 5); 
     // use a text-based format instead of the default XML-based format 
     logHandler.setFormatter(new SimpleFormatter()); 
     // get the actual Logger 
     logger = Logger.getLogger("com.example.foo"); 
     // Log to the file by associating the FileHandler with the log 
     logger.addHandler(logHandler); 
    } 
    catch (IOException ioe) { 
     // do something wise 
    } 

    // examples of using the logger 
    logger.finest("This message is only logged at the finest level (lowest/most-verbose level)"); 
    logger.config("This is an config-level message (middle level)"); 
    logger.severe("This is a severe-level message (highest/least-verbose level)"); 

Android Mechanizm logowania jest z pewnością łatwe i wygodne. Nie jest to jednak bardzo łatwe do dostosowania, a filtrowanie dziennika musi odbywać się za pomocą znaczników, które mogą łatwo stać się nieporęczne.Korzystając z interfejsu API java.uitl.logging, można uniknąć obsługi wielu znaczników, ale w łatwy sposób ograniczyć plik dziennika do określonych części aplikacji, uzyskać większą kontrolę nad położeniem i wyglądem dziennika, a nawet dostosować zachowanie rejestrowania w środowisku wykonawczym.

Answer 3

Repostuję moją odpowiedź tutaj, aby @JPM i inni mogli zobaczyć ... Kod w zasadzie po prostu wykonuje polecenie logcat, a następnie buduje dziennik ze strumienia wejściowego.

final StringBuilder log = new StringBuilder(); 
try {   
    ArrayList<String> commandLine = new ArrayList<String>(); 
    commandLine.add("logcat"); 
    commandLine.add("-d"); 
    ArrayList<String> arguments = ((params != null) && (params.length > 0)) ? params[0] : null; 
    if (null != arguments){ 
     commandLine.addAll(arguments); 
    } 

    Process process = Runtime.getRuntime().exec(commandLine.toArray(new String[0])); 
    BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(process.getInputStream())); 

    String line; 
    while ((line = bufferedReader.readLine()) != null){ 
     log.append(line); 
     log.append(LINE_SEPARATOR); 
    } 
} 
catch (IOException e){ 
     // 
} 

return log; 

Answer 4

wiem, że to jest późno odpowiedź na pytanie, ale chciałbym polecić korzystanie Logback pisać wiadomości do pliku dziennika, a także logcat.

1. Skopiuj logback-android-1.0.10-2.jar i slf4j-api-1.7.5.jar do swojego folderu libs.
2. Kliknij prawym przyciskiem myszy obie biblioteki i wybierz z menu opcję Buduj ścieżkę -> Dodaj do ścieżki budowania.
3. Utwórz plik w folderze logback.xml swoje aktywa i wprowadź następujące informacje:

    

    
    
    
     %msg 
    
    

    
    
    
     WARN 
    

    ${LOG_DIR}/log.txt 

    
     %d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n 
     
    

    
    
    
    
    

1. Aby napisać dziennik:

   public class MyActivity rozciąga aktywny {public static final Logger logger = LoggerFactory.getLogger (MyActivity.class);

   protected void onCreate(Bundle b) 
   { 
       super(b); 
       try{ 
        throw new Exception("Test"); 
       }catch(Exception e){ 
        logger.error("Something bad happened",e); 
       } 
   } 
   

   }