Cómo mostrar mensajes largos en logcat

Estoy tratando de mostrar un mensaje largo en logcat. Si la longitud del mensaje es de más de 1000 caracteres, se rompe.

¿Cuál es el mecanismo para mostrar todos los caracteres del mensaje largo en logcat?

Si logcat está limitando la longitud a 1000, entonces puede dividir la cadena que desea registrar con String.subString () y registrarla en pedazos. Por ejemplo:

int maxLogSize = 1000; for(int i = 0; i <= veryLongString.length() / maxLogSize; i++) { int start = i * maxLogSize; int end = (i+1) * maxLogSize; end = end > veryLongString.length() ? veryLongString.length() : end; Log.v(TAG, veryLongString.substring(start, end)); } 

Como continuación a la respuesta de spatulamania, escribí una clase contenedora que maneja esto para ti. Solo necesita cambiar la importación y registrará todo

 public class Log { public static void d(String TAG, String message) { int maxLogSize = 2000; for(int i = 0; i <= message.length() / maxLogSize; i++) { int start = i * maxLogSize; int end = (i+1) * maxLogSize; end = end > message.length() ? message.length() : end; android.util.Log.d(TAG, message.substring(start, end)); } } } 

Esto se basa en la respuesta de spatulamania, es un poco más sucinto y no agregará un mensaje de registro vacío al final:

 final int chunkSize = 2048; for (int i = 0; i < s.length(); i += chunkSize) { Log.d(TAG, s.substring(i, Math.min(s.length(), i + chunkSize))); } 

Pruebe este fragmento de código para mostrar el mensaje largo en logcat.

 public void logLargeString(String str) { if(str.length() > 3000) { Log.i(TAG, str.substring(0, 3000)); logLargeString(str.substring(3000)); } else { Log.i(TAG, str); // continuation } } 

Así es como lo hace OkHttp con HttpLoggingInterceptor:

 public void log(String message) { // Split by line, then ensure each line can fit into Log's maximum length. for (int i = 0, length = message.length(); i < length; i++) { int newline = message.indexOf('\n', i); newline = newline != -1 ? newline : length; do { int end = Math.min(newline, i + MAX_LOG_LENGTH); Log.d("OkHttp", message.substring(i, end)); i = end; } while (i < newline); } } 

MAX_LOG_LENGTH es 4000

Aquí usa Log.d (debug) y la etiqueta "OkHttp" codificada.

Divide el registro en líneas nuevas o cuando alcanza la longitud máxima.

Esta clase a continuación es una clase auxiliar que puedes usar (si tienes soporte lambda, tira a Jack & Jill o retrolambda) para hacer lo mismo que OkHttp en cualquier registro:

 /** * Help printing logs splitting text on new line and creating multiple logs for too long texts */ public class LogHelper { private static final int MAX_LOG_LENGTH = 4000; public static void v(@NonNull String tag, @Nullable String message) { log(message, line -> Log.v(tag, line)); } public static void d(@NonNull String tag, @Nullable String message) { log(message, line -> Log.d(tag, line)); } public static void i(@NonNull String tag, @Nullable String message) { log(message, line -> Log.i(tag, line)); } public static void w(@NonNull String tag, @Nullable String message) { log(message, line -> Log.w(tag, line)); } public static void e(@NonNull String tag, @Nullable String message) { log(message, line -> Log.e(tag, line)); } public static void v(@NonNull String tag, @Nullable String message, @Nullable Throwable throwable) { log(message, throwable, line -> Log.v(tag, line)); } public static void d(@NonNull String tag, @Nullable String message, @Nullable Throwable throwable) { log(message, throwable, line -> Log.d(tag, line)); } public static void i(@NonNull String tag, @Nullable String message, @Nullable Throwable throwable) { log(message, throwable, line -> Log.i(tag, line)); } public static void w(@NonNull String tag, @Nullable String message, @Nullable Throwable throwable) { log(message, throwable, line -> Log.w(tag, line)); } public static void e(@NonNull String tag, @Nullable String message, @Nullable Throwable throwable) { log(message, throwable, line -> Log.e(tag, line)); } private static void log(@Nullable String message, @NonNull LogCB callback) { if (message == null) { callback.log("null"); return; } // Split by line, then ensure each line can fit into Log's maximum length. for (int i = 0, length = message.length(); i < length; i++) { int newline = message.indexOf('\n', i); newline = newline != -1 ? newline : length; do { int end = Math.min(newline, i + MAX_LOG_LENGTH); callback.log(message.substring(i, end)); i = end; } while (i < newline); } } private static void log(@Nullable String message, @Nullable Throwable throwable, @NonNull LogCB callback) { if (throwable == null) { log(message, callback); return; } if (message != null) { log(message + "\n" + Log.getStackTraceString(throwable), callback); } else { log(Log.getStackTraceString(throwable), callback); } } private interface LogCB { void log(@NonNull String message); } } 

Para no minimizar la división de líneas entre los mensajes de registro, tomo la cadena grande y registro cada línea por separado.

 void logMultilineString(String data) { for (String line : data.split("\n")) { logLargeString(line); } } void logLargeString(String data) { final int CHUNK_SIZE = 4076; // Typical max logcat payload. int offset = 0; while (offset + CHUNK_SIZE <= data.length()) { Log.d(TAG, data.substring(offset, offset += CHUNK_SIZE)); } if (offset < data.length()) { Log.d(TAG, data.substring(offset)); } } 

Aquí hay una versión de Kotlin para la respuesta @spatulamania (especialmente para personas perezosas / inteligentes):

 val maxLogSize = 1000 val stringLength = yourString.length for (i in 0..stringLength / maxLogSize) { val start = i * maxLogSize var end = (i + 1) * maxLogSize end = if (end > yourString.length) yourString.length else end Log.v("YOURTAG", yourString.substring(start, end)) } 

Considero que Timber es una buena opción para este problema. La madera se divide automáticamente e imprime trozos de mensaje en logcat.

https://github.com/JakeWharton/timber

Puede ver la implementación del método de registro en la clase estática timber.log.Timber.DebugTree.