logcat Android to text file

Question

Please tell me that how can I write my own created logs to text file in device ?

I found this code in stackoverflow itself but this code it prints whole logcat, How can I filter the same?

public static void write() {


        try {
            Process process = Runtime.getRuntime().exec("logcat -d");

         //   Log.e("","******************---1");

            BufferedReader bufferedReader = new BufferedReader(
                    new InputStreamReader(process.getInputStream()));

            log = new StringBuilder();
            String line;
        //    Log.e("","******************---2");
            while ((line = bufferedReader.readLine()) != null) {
                log.append(line);
            }

        } catch (IOException exception) {
        }


        //convert log to string
        final String logString = new String(log.toString());

        //create text file in SDCard
        File sdCard = Environment.getExternalStorageDirectory();

      //  Log.e("","******************---3");

        File dir = new File(sdCard.getAbsolutePath() + "/myLogcat");
        dir.mkdirs();
        File file = new File(dir, "logcat.txt");

        try {
            //to write logcat in text file
            FileOutputStream fOut = new FileOutputStream(file);
            OutputStreamWriter osw = new OutputStreamWriter(fOut);

            // Write the string to the file
            osw.write(logString);
          //  Log.e("", "******************---4");

            osw.flush();
            osw.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

Answer 1

As a alternate way you can create your custom logger.

Here is one sample util class that I have created for my project.

import android.os.Environment;
import android.util.Log;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Locale;

/**
 * TODO: Add a class header comment!
 *
 * @author Dhaval Patel
 * @version 1.0, May 24, 2015
 * @since 1.0
 */
public final class Logger {

    public static final int MAX_FILE_SIZE  =  1024*1024*5;// max file size 5MB, if file size increase, Logger will create new file.
    private static final String LOG_PREFIX = "prefix_";
    private static final int LOG_PREFIX_LENGTH = LOG_PREFIX.length();
    private static final int MAX_LOG_TAG_LENGTH = 23;

    private static final Boolean ENABLE_CONSOLE_LOG = true;  //Flag to enable or disable console log
    private static final Boolean ENABLE_FILE_LOG = true;  //Flag to enable or disable file log

    private static final LogLevel GLOBAL_LOG_LEVEL = LogLevel.VERBOSE; //Flag indicate log level
    private static final String LOG_DIRECTORY = Environment.getExternalStorageDirectory()+"log"+File.separator; //Log directory

    public static String makeLogTag(String str) {
        if (str.length() > MAX_LOG_TAG_LENGTH - LOG_PREFIX_LENGTH) {
            return LOG_PREFIX + str.substring(0, MAX_LOG_TAG_LENGTH - LOG_PREFIX_LENGTH - 1);
        }
        return LOG_PREFIX + str;
    }

    private enum LogLevel{
        VERBOSE(Log.VERBOSE),
        DEBUG(Log.DEBUG),
        INFO(Log.INFO),
        WARNING(Log.WARN),
        ERROR(Log.ERROR),
        ASSERT(Log.ASSERT);

        private final int logLevel;
        LogLevel(int logLevel) {
            this.logLevel = logLevel;
        }

        public int getLogLevel() {
            return logLevel;
        }
    }


    /**
     *
     * @param tag Used to identify the source of a log message.  It usually identifies
     *            the class or activity where the log call occurs.
     * @param msg The message you would like logged.
     *
     */
    public static void v(String tag, String msg) {
        write(LogLevel.VERBOSE, tag, msg);
    }

    /**
     *
     * @param tag Used to identify the source of a log message.  It usually identifies
     *            the class or activity where the log call occurs.
     * @param msg The message you would like logged.
     * @param tr  An exception to log
     *
     */
    public static void v(String tag, String msg, Throwable tr) {
        write(LogLevel.VERBOSE, tag, msg, tr);
    }

    /**
     *
     * @param tag Used to identify the source of a log message.  It usually identifies
     *            the class or activity where the log call occurs.
     * @param msg The message you would like logged.
     *
     */
    public static void d(String tag, String msg) {
        write(LogLevel.DEBUG, tag, msg);
    }

    /**
     *
     * @param tag Used to identify the source of a log message.  It usually identifies
     *            the class or activity where the log call occurs.
     * @param msg The message you would like logged.
     * @param tr  An exception to log
     *
     */
    public static void d(String tag, String msg, Throwable tr) {
        write(LogLevel.DEBUG, tag, msg, tr);
    }

    /**
     *
     * @param tag Used to identify the source of a log message.  It usually identifies
     *            the class or activity where the log call occurs.
     * @param msg The message you would like logged.
     *
     */
    public static void i(String tag, String msg) {
        write(LogLevel.INFO, tag, msg);
    }

    /**
     *
     * @param tag Used to identify the source of a log message.  It usually identifies
     *            the class or activity where the log call occurs.
     * @param msg The message you would like logged.
     * @param tr  An exception to log
     *
     */
    public static void i(String tag, String msg, Throwable tr) {
        write(LogLevel.INFO, tag, msg, tr);
    }

    /**
     *
     * @param tag Used to identify the source of a log message.  It usually identifies
     *            the class or activity where the log call occurs.
     * @param msg The message you would like logged.
     *
     */
    public static void w(String tag, String msg) {
        write(LogLevel.WARNING, tag, msg);
    }

    /**
     *
     * @param tag Used to identify the source of a log message.  It usually identifies
     *            the class or activity where the log call occurs.
     * @param msg The message you would like logged.
     * @param tr  An exception to log
     *
     */
    public static void w(String tag, String msg, Throwable tr) {
        write(LogLevel.WARNING, tag, msg, tr);
    }

    /**
     *
     * @param tag Used to identify the source of a log message.  It usually identifies
     *            the class or activity where the log call occurs.
     * @param msg The message you would like logged.
     *
     */
    public static void e(String tag, String msg) {
        write(LogLevel.ERROR, tag, msg);
    }

    /**
     *
     * @param tag Used to identify the source of a log message.  It usually identifies
     *            the class or activity where the log call occurs.
     * @param msg The message you would like logged.
     * @param tr  An exception to log
     *
     */
    public static void e(String tag, String msg, Throwable tr) {
        write(LogLevel.ERROR, tag, msg, tr);
    }

    private static boolean isLogEnable(LogLevel logLevel){
        return GLOBAL_LOG_LEVEL.getLogLevel() <= logLevel.getLogLevel();
    }

    private static void write(LogLevel logLevel, String tag, String log) {
        if (isLogEnable(logLevel) && ENABLE_FILE_LOG){
            StackTraceElement stackTraceElement = Thread.currentThread().getStackTrace()[4];
            String logPoint = stackTraceElement.getClassName() + "." + stackTraceElement.getMethodName() + ":" + stackTraceElement.getLineNumber();
            String msg = "["+getCurrentDateTime()+"] "+ logLevel.name() +" "+ logPoint +" "+tag+"//:"+log;
            write(msg);
        }

        if (isLogEnable(logLevel) && ENABLE_CONSOLE_LOG){
            Log.println(logLevel.getLogLevel(), makeLogTag(tag), log);
        }
    }

    private static void write(LogLevel logLevel, String tag, String log, Throwable tr){
        if (isLogEnable(logLevel) && ENABLE_FILE_LOG){
            StackTraceElement stackTraceElement = Thread.currentThread().getStackTrace()[4];
            String logPoint = stackTraceElement.getClassName() + "::" + stackTraceElement.getMethodName() + ":" + stackTraceElement.getLineNumber();
            String msg = "["+getCurrentDateTime()+"] "+ logLevel.name() +" "+ logPoint+" "+tag+"//:"+log+"\n"+Log.getStackTraceString(tr);
            write(msg);
        }

        if (isLogEnable(logLevel) && ENABLE_CONSOLE_LOG){
            Log.println(logLevel.getLogLevel(), makeLogTag(tag), log + "\n" + Log.getStackTraceString(tr));
        }
    }

    private static void write(String text){
        BufferedWriter out = null;
        String filePath=LOG_DIRECTORY;
        try {

            SimpleDateFormat df = new SimpleDateFormat("dd_MMM_yyyy", Locale.ENGLISH);
            String formattedDate = df.format(System.currentTimeMillis());

            if(!new File(LOG_DIRECTORY).exists()) {
                new File(LOG_DIRECTORY).mkdirs();
            }

            filePath = LOG_DIRECTORY +formattedDate+".log";
            while (new File(filePath).exists() && new File(filePath).length() > MAX_FILE_SIZE) {
                String[] txt1 = filePath.split("\\.log");
                int fileNum = 1;
                if (txt1.length == 2) {
                    fileNum = Integer.parseInt(txt1[1].substring(1));
                    fileNum++;
                }
                filePath = LOG_DIRECTORY + formattedDate + ".log" + "." + fileNum;
            }

            if(!new File(filePath).exists()){
                new File(filePath).createNewFile();
            }

            if(new File(filePath).exists()){
                FileWriter fStream = new FileWriter(filePath, true);
                out = new BufferedWriter(fStream);
                out.write(text + "\n" + new File(filePath).length());
                out.flush();
            }
        } catch (IOException e) {
            Log.e("Log", "Path:"+filePath);
            e.printStackTrace();
        } catch (Exception e) {
            Log.e("Log", e.getMessage());
            e.printStackTrace();
        } finally {
            try {
                if(out!=null)
                    out.close();

            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    private static String getCurrentDateTime(){
        return new SimpleDateFormat("dd MMM yyyy HH:mm:ss:SSS" , Locale.getDefault()).format(Calendar.getInstance().getTime());
    }
}

Use it same like your android Log.

Logger.i("Info", "my sample log");

Here log store in file date-wise, you can modify write method as per your needs.

Answer 2

First check out the log locations here: https://android.stackexchange.com/questions/14430/how-can-i-view-and-examine-the-android-log

If that's not good enough, you can always make your own Log.java class which would log directly to the file you want (though you should really reconsider using LogCat as it is working as expected).

Answer 3

Try this :

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);
      }
      appendLog(log.toString());
    } catch (IOException e) {
    }

Method to write log to file:

public void appendLog(String text) {
        File logFile = new File("sdcard/Log.txt");
        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();
        }
    }

Add the following permission in manifest file also :

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