Android escribiendo registros en el archivo de texto

Estoy intentando escribir registros en el archivo Log.txt personalizado en el archivo Android usando este código de Mine pero luego este método crea el archivo pero no contiene nada. Básicamente, quiero leer los contenidos anteriores del archivo y luego anexar mis datos con el contenido existente.

El código es el siguiente :

public static void write(String str) { InputStream fileInputStream = null; FileOutputStream fileOutpurStream = null; try { fileInputStream = new FileInputStream(file); fileOutpurStream = new FileOutputStream(file); if(file.exists()) { int ch = 0; int current = 0; StringBuffer buffer = new StringBuffer(); while((ch = fileInputStream.read()) != -1) { buffer.append((char) ch); current++; } byte data[]=new byte[(int)file.length()]; fileInputStream.read(data); fileOutpurStream.write(data); fileOutpurStream.write(str.getBytes(),0,str.getBytes().length); fileOutpurStream.flush(); } else { file.createNewFile(); fileOutpurStream.write(str.getBytes(),0,str.getBytes().length); fileOutpurStream.flush(); } } catch(Exception e) { e.printStackTrace(); } finally { try { fileInputStream.close(); fileOutpurStream.flush(); fileOutpurStream.close(); fileOutpurStream = null; fileInputStream = null; } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } 

Espero que esto pueda ayudar …

 public void appendLog(String text) { File logFile = new File("sdcard/log.file"); if (!logFile.exists()) { try { logFile.createNewFile(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } try { //BufferedWriter for performance, true to set append to file flag BufferedWriter buf = new BufferedWriter(new FileWriter(logFile, true)); buf.append(text); buf.newLine(); buf.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } 

Para los nuevos en el registro de Java en general y el registro de Android

  1. Log4j es la implementación genérica de registro de java y ahora es un proyecto de la base de software Apache. No es específico de Android y tiene algunas incompatibilidades con Android.
  2. SL4J no es una implementación de registro, es una capa de abstracción. Ayuda a evitar situaciones como las dependencias de cada biblioteca de terceros a un proyecto, tratando de usar su propia implementación de registro como Log4j. Fuente

Algunas opciones para iniciar sesión en txt en Android están por debajo

  1. Use logcat -f como en esta respuesta para iniciar sesión en el archivo. Tenga en cuenta que, desde Android 4.2, el permiso READ_LOGS no tiene ningún impacto y que cada aplicación (a menos que el teléfono esté rooteado) solo puede leer sus propios registros. La desventaja aquí es que el buffer de logcat es circular y tiene un límite de tamaño. Es posible que no obtenga los registros anteriores.
  2. Use microlog4android (escrito para dispositivos móviles como Android) como en la respuesta anterior. Podría haber una manera, pero no podía entender, cómo usar microlog4Android para iniciar sesión en el almacenamiento interno de la aplicación. La única opción para la ruta de registros fue el almacenamiento externo, como sdcard, por lo que no pude usarlo.
  3. Use Log4j con android-logging-log4j . ¿Qué hace android-logging-log4j? Hace Log4j más fácil de usar en Android dando dos funciones.

    • opción para enviar registros a logcat además del archivo de registro
    • una forma sencilla de configurar las opciones de configuración de Log4j, como la ruta del archivo, el tamaño máximo del archivo, el número de copias de seguridad, etc., al proporcionar la clase LogConfigurator.

    Ejemplo simple a continuación. Observe que el objeto logger en el ejemplo siguiente es un objeto Log4j devuelto y no una clase android-logging-log4j. Entonces, android-logging-log4j se usa solo para configurar Log4j.

  4. Sin embargo, para probar LogBack . LogBack fue desarrollado por la misma persona que creó las bibliotecas Log4J 1.xy SL4J. Sin embargo, no está relacionado con Log4j 2.x.

Pasos para usar Log4j en Android.

  1. Agregue ambos log4j-1.2.x.jar y android-logging-log4j-1.0.3.jar a la carpeta libs.

  2. Agregue permisos solo si usa almacenamiento externo

  3. Escribir clase de ayuda Log4j

     package com.example.logger; import android.os.Environment; import de.mindpipe.android.logging.log4j.LogConfigurator; public class Log4jHelper { private final static LogConfigurator mLogConfigrator = new LogConfigurator(); static { configureLog4j(); } private static void configureLog4j() { String fileName = Environment.getExternalStorageDirectory() + "/" + "log4j.log"; String filePattern = "%d - [%c] - %p : %m%n"; int maxBackupSize = 10; long maxFileSize = 1024 * 1024; configure( fileName, filePattern, maxBackupSize, maxFileSize ); } private static void configure( String fileName, String filePattern, int maxBackupSize, long maxFileSize ) { mLogConfigrator.setFileName( fileName ); mLogConfigrator.setMaxFileSize( maxFileSize ); mLogConfigrator.setFilePattern(filePattern); mLogConfigrator.setMaxBackupSize(maxBackupSize); mLogConfigrator.setUseLogCatAppender(true); mLogConfigrator.configure(); } public static org.apache.log4j.Logger getLogger( String name ) { org.apache.log4j.Logger logger = org.apache.log4j.Logger.getLogger( name ); return logger; } } 
  4. En clase de actividad

     org.apache.log4j.Logger log= Log4jHelper.getLogger( "YourActivity" ); log.error("Error"); log.info("Info"); log.warn("Warn"); 

Fuente de ejemplo . Tenga en cuenta que log4j 2.x (funcionalidades mejoradas) reescrito desde cero no es comstackble hacia atrás con log4j 1.x. Por lo tanto, debe usar log4j 1.2.x jar con android-logging-log4j jar. Pude iniciar sesión en el archivo interno de la aplicación y luego enviar el archivo por correo electrónico con setReadable(true, false)

microlog4android funciona para mí, pero la documentación es bastante pobre. Todo lo que necesitan agregar es que este es un tutorial de inicio rápido.

Aquí hay un tutorial rápido que encontré.

  1. Agregue la siguiente variable estática en su actividad principal:

     private static final Logger logger = LoggerFactory.getLogger(); 
  2. Agregue lo siguiente a su método onCreate() :

     PropertyConfigurator.getConfigurator(this).configure(); 
  3. Crea un archivo llamado microlog.properties y microlog.properties en el directorio de assets

  4. Edite el archivo microlog.properties la siguiente manera:

     microlog.level=DEBUG microlog.appender=LogCatAppender;FileAppender microlog.formatter=PatternFormatter microlog.formatter.PatternFormatter.pattern=%c [%P] %m %T 
  5. Agregue declaraciones de inicio de sesión como esta:

     logger.debug("M4A"); 

Para cada clase, usted crea un objeto logger como se especifica en 1)

6. Puede agregar el siguiente permiso:

   

Aquí está la fuente para el tutorial

Advertencia: es posible que te esté malinterpretando por completo, pero si todo lo que quieres es un archivo de registro, ¿por qué sudar?

Coloque esto en un archivo bat (cambie la ruta al directorio de herramientas, y su nombre de aplicación es, por supuesto, el nombre de su aplicación):

 cd "C:\devAndroid\Software\android-sdk-windows-1.6_r1\android-sdk-windows-1.6_r1\tools" adb logcat -v time ActivityManager:W yourappname:D *:W >"C:\devAndroid\log\yourappname.log" 

Luego, en tu código simplemente haz algo similar a esto:

 Log.d("yourappname", "Your message"); 

Para crear el registro, conecte el cable USB y ejecute su archivo bat.

Saludos

Deberías echarle un vistazo a microlog4android. Tienen una solución lista para iniciar sesión en un archivo.

http://code.google.com/p/microlog4android/

Esto puede ser tarde, pero espero que esto ayude … Prueba esto …

 public void writefile() { File externalStorageDir = Environment.getExternalStorageDirectory(); File myFile = new File(externalStorageDir , "yourfilename.txt"); if(myFile.exists()) { try { FileOutputStream fostream = new FileOutputStream(myFile); OutputStreamWriter oswriter = new OutputStreamWriter(fostream); BufferedWriter bwriter = new BufferedWriter(oswriter); bwriter.write("Hi welcome "); bwriter.newLine(); bwriter.close(); oswriter.close(); fostream.close(); } catch (IOException e) { e.printStackTrace(); } } else { try { myFile.createNewFile(); } catch (IOException e) { e.printStackTrace(); } } 

aquí bfwritter.newline escribe su texto en el archivo. Y agrega el permiso

   

en su archivo de manifiesto sin falta.

Utilice slf4android lib.
Es una implementación simple de slf4j api usando android java.util.logging. *.

caracteristicas:

  • logging para archivar de la caja
  • iniciar sesión en cualquier otro destino mediante LoggerConfiguration.configuration().addHandlerToLogger
  • agita tu dispositivo para enviar registros con captura de pantalla por correo electrónico
  • realmente pequeño, solo tomó ~ 55kB

slf4android se mantiene principalmente por @miensol .

Lea más sobre slf4android en nuestro blog:

  • Presentando slf4android
  • Integre slf4android con Crashlytics

Resolví este problema con la siguiente pieza de código en la línea de comando:

 File outputFile = new File("pathToFile"); Runtime.getRuntime().exec("logcat -c"); Runtime.getRuntime().exec("logcat -v time -f " + outputFile.getAbsolutePath()) 

Donde la opción “tiempo” agrega detalles del campo de metadatos para la fecha, el tiempo de invocación, la prioridad / etiqueta y el PID del proceso que emite el mensaje.

Luego, en su código simplemente haga algo similar a esto (usando android.util.Log):

 Log.d("yourappname", "Your message"); 

En general, debe tener un identificador de archivo antes de abrir la transmisión. Tiene un manejador fileOutputStream antes de createNewFile () en el bloque else. La transmisión no crea el archivo si no existe.

No es realmente específico de Android, pero eso es mucho IO para este propósito. ¿Qué pasa si haces muchas operaciones de “escritura” una después de otra? Leerá todo el contenido y escribirá todo el contenido, tomando su tiempo y, lo que es más importante, la duración de la batería.

Sugiero usar java.io.RandomAccessFile, seek () ‘ing hasta el final, luego writeChars () para anexar. Será un código mucho más limpio y probablemente mucho más rápido.

Creé una clase simple y liviana (aproximadamente 260 LoC) que extiende la implementación estándar de android.util.Log con el registro basado en archivos:
Cada mensaje de registro se registra a través de android.util.Log y también se escribe en un archivo de texto en el dispositivo.

Puedes encontrarlo en github:
https://github.com/volkerv/FileLog

Esta variante es mucho más corta

 tratar {
     ruta de archivo final = archivo nuevo (
             Environment.getExternalStorageDirectory (), "DBO_logs5");
     if (! path.exists ()) {
         path.mkdir ();
     }
     Runtime.getRuntime (). Exec (
             "logcat -d -f" + path + File.separator
                     + "dbo_logcat"
                     + ".txt");
 } catch (IOException e) {
     e.printStackTrace ();
 }

Puedes usar la biblioteca que he escrito. Es muy fácil de usar:

Agregue esta dependencia a su archivo gradle:

 dependencies { compile 'com.github.danylovolokh:android-logger:1.0.2' } 

Inicializa la biblioteca en la clase de aplicación:

 File logsDirectory = AndroidLogger.getDefaultLogFilesDirectory(this); int logFileMaxSizeBytes = 2 * 1024 * 1024; // 2Mb try { AndroidLogger.initialize( this, logsDirectory, "Log_File_Name", logFileMaxSizeBytes, false ); } catch (IOException e) { // Some error happened - most likely there is no free space on the system } 

Esta es la forma en que usa la biblioteca:

 AndroidLogger.v("TAG", "Verbose Message"); 

Y esta es la forma de recuperar los registros:

 AndroidLogger.processPendingLogsStopAndGetLogFiles(new AndroidLogger.GetFilesCallback() { @Override public void onFiles(File[] logFiles) { // get everything you need from these files try { AndroidLogger.reinitAndroidLogger(); } catch (IOException e) { e.printStackTrace(); } } }); 

Aquí está el enlace a la página de github con más información: https://github.com/danylovolokh/AndroidLogger

Espero eso ayude.