Android schreibt Protokolle in eine Textdatei

Ich versuche, Protokolle mit diesem Code von mir in eine benutzerdefinierte Log.txt-Datei auf einer Android-Datei zu schreiben, aber dann erstellt diese Methode eine Datei, enthält aber nichts. Grundsätzlich möchte ich den vorherigen Inhalt der Datei lesen und dann meine Daten an den vorhandenen Inhalt anhängen.

Der Kodex lautet wie folgt:

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

Hoffe das kann helfen ...

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

Für diejenigen, die noch keine Erfahrung mit Java-Protokollierung im Allgemeinen und Android-Protokollierung haben

1. Log4j ist eine generische Java-Protokollierungsimplementierung und jetzt ein Projekt der Apache Software Foundation. Es ist nicht Android-spezifisch und weist daher einige Inkompatibilitäten mit Android auf.
2. SL4J ist keine Protokollierungsimplementierung, sondern eine Abstraktionsschicht. Es hilft dabei, Situationen wie die Abhängigkeit jeder Drittanbieter-Bibliothek von einem Projekt zu vermeiden und zu versuchen, eine eigene Protokollierungsimplementierung wie Log4j zu verwenden. Quelle .

Einige Optionen für die Protokollierung bei txt in Android sind unten aufgeführt

1. Verwenden Sie logcat -fwie in dieser Antwort, um sich in einer Datei anzumelden. Beachten Sie, dass die READ_LOGS-Berechtigung ab Android 4.2 keine Auswirkungen hat und jede Anwendung (sofern das Telefon nicht gerootet ist) nur ihre eigenen Protokolle lesen konnte. Der Nachteil hierbei ist, dass der Logcat-Puffer kreisförmig ist und eine Größenbeschränkung aufweist. Möglicherweise erhalten Sie keine früheren Protokolle.
2. Verwenden Sie microlog4android (geschrieben für mobile Geräte wie Android) wie in der vorherigen Antwort . Es könnte einen Weg geben, aber ich konnte mir nicht vorstellen, wie ich microlog4Android für die Protokollierung im internen Speicher der Anwendung verwenden soll. Die einzige Option für den Protokollpfad war externer Speicher wie SD-Karte, sodass ich ihn nicht verwenden konnte.

3. Verwenden Sie Log4j mit android-logging-log4j . Was macht android-logging-log4j? Es erleichtert die Verwendung von Log4j in Android, indem es zwei Funktionen bietet.

   • Option zum Senden von Protokollen an logcat zusätzlich zur Protokolldatei
   • Eine einfache Möglichkeit, Log4j-Konfigurationsoptionen wie Dateipfad, maximale Dateigröße, Anzahl der Sicherungen usw. festzulegen, indem die LogConfigurator-Klasse bereitgestellt wird.

   Einfaches Beispiel unten. Beachten Sie, dass das loggerObjekt im folgenden Beispiel ein zurückgegebenes Log4j-Objekt und keine android-logging-log4j-Klasse ist. Daher wird android-logging-log4j nur zum Konfigurieren von Log4j verwendet.

4. Noch LogBack zu versuchen . LogBack wurde von derselben Person entwickelt, die die Bibliotheken Log4J 1.x und SL4J entwickelt hat. Nicht verwandt mit Log4j 2.x.

Schritte zur Verwendung von Log4j in Android.

1. Fügen Sie dem Ordner libs sowohl log4j-1.2.x.jar als auch android-logging-log4j-1.0.3.jar hinzu.

2. Fügen Sie Berechtigungen nur hinzu, wenn Sie externen Speicher verwenden
   <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>

3. Schreibe eine Log4jHilfsklasse

   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. In der Aktivitätsklasse

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

Beispielquelle . Beachten Sie, dass log4j 2.x (verbesserte Funktionen), das von Grund auf neu geschrieben wurde, mit log4j 1.x nicht abwärtskompatibel ist. Sie müssen also log4j 1.2.x jar mit android-logging-log4j jar verwenden. Ich konnte mich in der anwendungsinternen Datei anmelden und die Datei später per E-Mail sendensetReadable(true, false)

microlog4android funktioniert bei mir, aber die Dokumentation ist ziemlich schlecht. Alles, was sie hinzufügen müssen, ist ein Schnellstart- Tutorial .

Hier ist ein kurzes Tutorial, das ich gefunden habe.

1. Fügen Sie Ihrer Hauptaktivität die folgende statische Variable hinzu:

   private static final Logger logger = LoggerFactory.getLogger();

2. Fügen Sie Ihrer onCreate()Methode Folgendes hinzu :

   PropertyConfigurator.getConfigurator(this).configure();

3. Erstellen Sie eine Datei mit dem Namen microlog.propertiesund speichern Sie sie im assetsVerzeichnis

4. Bearbeiten Sie die microlog.propertiesDatei wie folgt:

   microlog.level=DEBUG
   microlog.appender=LogCatAppender;FileAppender
   microlog.formatter=PatternFormatter
   microlog.formatter.PatternFormatter.pattern=%c [%P] %m %T

5. Fügen Sie folgende Protokollierungsanweisungen hinzu:

   logger.debug("M4A");

Für jede Klasse erstellen Sie ein Logger-Objekt wie in 1) angegeben.

6.Sie können die folgende Berechtigung hinzufügen:

    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />

Hier ist die Quelle für das Tutorial

Warnung: Ich verstehe Sie vielleicht völlig falsch, aber wenn Sie nur eine Protokolldatei wollen, warum dann schwitzen?

Fügen Sie dies in eine Bat-Datei ein (ändern Sie den Pfad zu Ihrem Tools-Verzeichnis, und Ihr App-Name ist natürlich der Name Ihrer App):

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"

Dann machen Sie in Ihrem Code einfach etwas Ähnliches:

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

Um das Protokoll zu erstellen, schließen Sie das USB-Kabel an und führen Sie Ihre Bat-Datei aus.

Grüße

Verwenden Sie slf4android lib.
Es ist eine einfache Implementierung der slf4j-API mit android java.util.logging. *.

Eigenschaften:

• Protokollierung in Datei aus der Box
• Protokollierung an einem anderen Ziel durch LoggerConfiguration.configuration().addHandlerToLogger
• Schütteln Sie Ihr Gerät, um Protokolle mit Screenshot per E-Mail zu senden
• wirklich klein, es dauerte nur ~ 55kB

slf4android wird hauptsächlich von @miensol gepflegt .

Lesen Sie mehr über slf4android in unserem Blog:

• Einführung in slf4android
• Integrieren Sie slf4android in Crashlytics

Sie sollten einen Blick auf microlog4android werfen. Sie haben eine Lösung bereit, um sich in einer Datei anzumelden.

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

Dies kann spät sein, aber ich hoffe, dies kann helfen. Versuchen Sie dies ...

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

Hier bfwritter.newlineschreibt Ihr Text in die Datei. Und fügen Sie die Erlaubnis hinzu

 <uses-permission android:name = "android.permission.WRITE_EXTERNAL_STORAGE"/>

in Ihrer Manifest-Datei ohne Fehler.

Ich habe dieses Problem mit folgendem Code in der Befehlszeile gelöst:

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

Wobei die Option "Uhrzeit" Metadatenfelddetails für Datum, Aufrufzeit, Priorität / Tag und PID des Prozesses, der die Nachricht ausgibt, hinzufügt.

Dann machen Sie in Ihrem Code einfach etwas Ähnliches (mit android.util.Log):

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

Im Allgemeinen müssen Sie über ein Dateihandle verfügen, bevor Sie den Stream öffnen. Sie haben ein fileOutputStream-Handle vor createNewFile () im else-Block. Der Stream erstellt die Datei nicht, wenn sie nicht vorhanden ist.

Nicht wirklich androidspezifisch, aber das ist viel IO für diesen Zweck. Was ist, wenn Sie viele "Schreib" -Operationen nacheinander ausführen? Sie lesen den gesamten Inhalt und schreiben den gesamten Inhalt, nehmen sich Zeit und vor allem die Akkulaufzeit.

Ich schlage vor, java.io.RandomAccessFile zu verwenden, bis zum Ende zu suchen () und dann zum Anhängen writeChars () zu schreiben. Es wird viel sauberer Code sein und wahrscheinlich viel schneller.

Ich habe eine einfache, leichtgewichtige Klasse (ca. 260 LoC) erstellt, die die Standardimplementierung von android.util.Log um dateibasierte Protokollierung erweitert:
Jede Protokollnachricht wird über android.util.Log protokolliert und auch in eine Textdatei auf dem Gerät geschrieben.

Sie finden es auf github:
https://github.com/volkerv/FileLog

Nach langer Zeit der Untersuchung stellte ich fest, dass:

• android.util.Log Standardmäßig verwenden java.util.logging.Logger
• LogCat verwendet loggermit name "", um die Instanz davon zu verwendenLogManager.getLogManager().getLogger("")
• Android-Geräte ergänzen die LogCat- loggerInstanz com.android.internal.logging.AndroidHandlernach dem Ausführen von Debug-Apps
• Aber!!! com.android.internal.logging.AndroidHandlerdruckt Nachrichten nur mit höheren Ebenen java.util.logging.Level.INFOals ( Level.INFO, Level.WARNING, Level.SEVERE, Level.OFF) an logcat

Um also Protokolle in eine Datei zu schreiben, rootLogger "" fügen Sie einfach Folgendes hinzu java.util.logging.FileHandler:

  class App : Application{
    override fun onCreate() {
      super.onCreate()
      Log.d(TAG, printLoggers("before setup"))

      val rootLogger = java.util.logging.LogManager.getLogManager().getLogger("")
      val dirFile = destinationFolder
      val file = File(dirFile,"logFile.txt")
      val handler = java.util.logging.FileHandler(file.absolutePath, 5* 1024 * 1024/*5Mb*/, 1, true)
      handler.formatter = AndroidLogFormatter(filePath = file.absolutePath)

      rootLogger?.addHandler(handler)

      Log.d(TAG, printLoggers("after setup"))
    }
  }

val destinationFolder: File
        get() {
            val parent = 
                Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOWNLOADS).absoluteFile
            val destinationFolder = File(parent, "MyApp")
            if (!destinationFolder.exists()) {
                destinationFolder.mkdirs()
                destinationFolder.mkdir()
            }
            return destinationFolder
        }

class AndroidLogFormatter(val filePath: String = "", var tagPrefix: String = "") : Formatter() {

    override fun format(record: LogRecord): String {
        val tag = record.getTag(tagPrefix)
        val date = record.getDate()
        val level = record.getLogCatLevel()
        val message = record.getLogCatMessage()
        return "$date $level$tag: $message\n"
    }
}

fun LogRecord.getTag(tagPrefix: String): String {
    val name = loggerName
    val maxLength = 30
    val tag = tagPrefix + (if (name.length > maxLength) name.substring(name.length - maxLength) else name)
    return tag
}

fun LogRecord.getDate(): String? {
    return Date(millis).formatedBy("yyyy-MM-dd HH:mm:ss.SSS")
}

fun Date?.formatedBy(dateFormat: String): String? {
    val date = this
    date ?: return null
    val writeFormat = SimpleDateFormat(dateFormat, Locale.getDefault()) //MM в HH:mm
    return writeFormat.format(date)
}

fun LogRecord.getLogCatMessage(): String {
    var message = message

    if (thrown != null) {
        message += Log.getStackTraceString(thrown)
    }
    return message
}

fun Int.getAndroidLevel(): Int {
    return when {
        this >= Level.SEVERE.intValue() -> { // SEVERE
            Log.ERROR
        }
        this >= Level.WARNING.intValue() -> { // WARNING
            Log.WARN
        }
        this >= Level.INFO.intValue() -> { // INFO
            Log.INFO
        }
        else -> {
            Log.DEBUG
        }
    }
}

fun LogRecord.getLogCatLevel(): String {
    return when (level.intValue().getAndroidLevel()) {
        Log.ERROR -> { // SEVERE
            "E/"
        }
        Log.WARN -> { // WARNING
            "W/"
        }
        Log.INFO -> { // INFO
            "I/"
        }
        Log.DEBUG -> {
            "D/"
        }
        else -> {
            "D/"
        }
    }
}

fun getLoggerLevel(level: Int): Level {
    return when (level) {
        Log.ERROR -> { // SEVERE
            Level.SEVERE
        }
        Log.WARN -> { // WARNING
            Level.WARNING
        }
        Log.INFO -> { // INFO
            Level.INFO
        }
        Log.DEBUG -> {
            Level.FINE
        }
        else -> {
            Level.FINEST
        }
    }
}

Um alle Logger in Ihrer App zu drucken, verwenden Sie:

Log.e(TAG, printLoggers("before setup"))

 private fun printLoggers(caller: String, printIfEmpty: Boolean = true): String {
        val builder = StringBuilder()
        val loggerNames = LogManager.getLogManager().loggerNames
        builder.appendln("--------------------------------------------------------------")
        builder.appendln("printLoggers: $caller")
        while (loggerNames.hasMoreElements()) {
            val element = loggerNames.nextElement()
            val logger = LogManager.getLogManager().getLogger(element)
            val parentLogger: Logger? = logger.parent
            val handlers = logger.handlers
            val level = logger?.level
            if (!printIfEmpty && handlers.isEmpty()) {
                continue
            }
            val handlersNames = handlers.map {
                val handlerName = it.javaClass.simpleName
                val formatter: Formatter? = it.formatter
                val formatterName = if (formatter is AndroidLogFormatter) {
                    "${formatter.javaClass.simpleName}(${formatter.filePath})"
                } else {
                    formatter?.javaClass?.simpleName
                }
                "$handlerName($formatterName)"
            }
            builder.appendln("level: $level logger: \"$element\" handlers: $handlersNames parentLogger: ${parentLogger?.name}")
        }
        builder.appendln("--------------------------------------------------------------")
        return builder.toString()
    }

Diese Variante ist viel kürzer

Versuchen {
    endgültiger Dateipfad = neue Datei (
            Environment.getExternalStorageDirectory (), "DBO_logs5");
    if (! path.exists ()) {
        path.mkdir ();
    }}
    Runtime.getRuntime (). Exec (
            "logcat -d -f" + Pfad + File.separator
                    + "dbo_logcat"
                    + ".txt");
} catch (IOException e) {
    e.printStackTrace ();
}}

Sie können die Bibliothek verwenden, die ich geschrieben habe. Es ist sehr einfach zu bedienen:

Fügen Sie diese Abhängigkeit Ihrer Gradle-Datei hinzu:

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

Initialisieren Sie die Bibliothek in der Application-Klasse:

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
    }

So verwenden Sie die Bibliothek:

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

Und so rufen Sie die Protokolle ab:

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

Hier ist der Link zur Github-Seite mit weiteren Informationen: https://github.com/danylovolokh/AndroidLogger

Ich hoffe es hilft.

Viele der vorherigen Versionen von log4j funktionieren jetzt nicht (05/2019). Aber Sie können Hyperlog verwenden - ich kann bestätigen, dass es funktioniert.

1. Fügen Sie diese Zeile Ihrem Abhängigkeits- und Synchronisierungsprojekt hinzu

   implementation 'com.hypertrack:hyperlog:0.0.10'

2. Erstellen Sie eine neue Anwendungsklasse (erstellen Sie eine neue Java-Klasse und erweitern Sie die Anwendung). Fügen Sie dann in der onCreate-Methode die folgenden Zeilen hinzu:

   HyperLog.initialize(this);
   HyperLog.setLogLevel(Log.VERBOSE);
   
   HyperLog.getDeviceLogsInFile(this);

3. Ändern Sie die Manifestdatei so, dass die Anwendungsdatei definiert ist.

   <application
       android:name=".AppClass"
       .....

4. Verschiedene Arten der Protokollierung:

   HyperLog.d(TAG,"debug");
   HyperLog.i(TAG,"information");
   HyperLog.e(TAG,"error");
   HyperLog.v(TAG,"verbose");
   HyperLog.w(TAG,"warning");
   HyperLog.a(TAG,"assert");
   HyperLog.exception(TAG,"exception",throwable);

5. Finden Sie Ihre Protokolldateien. Navigieren Sie zu

   RootFolder/android/data/"appPackageName/LogFiles/