flujo de salida Logcat androide en una tarjeta SD

Question

Quiero lograr los siguientes, pero hasta ahora, no hay suerte

• Abrir un archivo en la tarjeta SD cuando la aplicación androide inició por primera vez.
• Transmita la salida de logcat al archivo.
• Cuando la aplicación finalice, detenga la transmisión de logcat.

En mi ApplicationClass extiende Método de aplicación onCreate(), hago esto

wwLogManager.openLogFile(); 

y aquí está el código en el 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); 

me pongo los archivos de registro en el SD tarjeta, pero el resultado del registro en estos archivos no tiene ningún rastro de las llamadas Log.i() que coloqué en mis actividades. ¿El comando logcat que utilicé aquí es correcto? ¡Gracias!

Answer 1

Prueba a poner un filtro manualmente como se describe aquí: http://developer.android.com/guide/developing/debugging/debugging-log.html#filteringOutput

Algo así como:

logcat ActivityManager:I MyApp:V *:S 

Si reemplaza "MyApp" con las etiquetas de registro que está utilizando, que debe mostrar toda la información (y mayores) registros de ActivityManager, y todos los registros detallados (y mayores) de su aplicación.

Answer 2

Pido disculpas si no entiendo bien sus objetivos, pero tal vez podría usar el java.util.logging API en lugar de utilizar Logcat o el mecanismo de registro de Android.

Al igual que el API de registro de Android, el java.util.logging API le permite acceder fácilmente mensajes a varios niveles, tales como FINO, más fino, WARN, GRAVES, etc.

Pero la API estándar de registro tiene ventajas adicionales, también. Por ejemplo, puede crear fácilmente un archivo de registro utilizando un FileHandler. De hecho, FileHandler tiene un mecanismo incorporado de rotación de registros, por lo que no tiene que preocuparse (demasiado) por limpiar los archivos de registro. También puede crear una jerarquía de Logger s; así, por ejemplo, si tiene dos Logger s, com.example.foo y com.example.foo.bar, cambiar el nivel de registro de la primera también cambiará el nivel de registro de la última. ¡Esto incluso funcionará si los dos Logger s se crean en diferentes clases! Además, cambia el comportamiento de registro en tiempo de ejecución especificando un archivo de configuración de registro. Finalmente, puede personalizar el formato del registro implementando su propio Formatter (o simplemente use el SimpleFormatter para evitar el formato XML predeterminado).

para utilizar la API de registro estándar, puede intentar algo como esto:

// 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)"); 

El mecanismo de registro de Android es ciertamente fácil y conveniente. Sin embargo, no es muy personalizable y el filtrado de registros debe hacerse con etiquetas, que pueden volverse difíciles de manejar.Al utilizar la API java.uitl.logging, puede evitar lidiar con una multitud de etiquetas, limitar fácilmente el archivo de registro a partes específicas de su aplicación, obtener un mayor control sobre la ubicación y apariencia del registro, e incluso personalizar el comportamiento de registro en tiempo de ejecución.

Answer 3

Publiqué mi respuesta aquí para que @JPM y otros puedan ver ... El código básicamente solo ejecuta el comando logcat y luego construye el registro desde el flujo de entrada.

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

Sé que esto es una respuesta tardía a la pregunta, pero yo recomendaría encarecidamente utilizar Logback a escribir mensajes en un archivo de registro, así como la Logcat.

1. Copie logback-android-1.0.10-2.jar y slf4j-api-1.7.5.jar en la carpeta libs.
2. Haga clic con el botón derecho en ambas bibliotecas y, en el menú, seleccione Ruta de compilación -> Agregar a compilación.
3. Crear un archivo en la carpeta de logback.xml activos y escriba lo siguiente:

    

    
    
    
     %msg 
    
    

    
    
    
     WARN 
    

    ${LOG_DIR}/log.txt 

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

    
    
    
    
    

1. Para escribir un registro:

   MyActivity clase pública se extiende Actividad { público 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); 
       } 
   } 
   

   }