如何在 logcat 中显示长消息

小开

最佳答案

If logcat is capping the length at 1000 then you can split the string you want to log with String.subString() and log it in pieces. For example:

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

小开

As a follow on to spatulamania answer I wrote a wrapper class which handles this for you. You just need to change the import and it will log everything

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


}

小开

Try this piece of code to show long message in 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
}
}

小开

This builds on spatulamania's answer, is a little more succinct, and won't add an empty log message at the end:

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

小开

In order not to minimize splitting lines across log messages, I take the large string and log each line separately.

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

小开

This is how OkHttp with HttpLoggingInterceptor does it:

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 is 4000.

Here it use Log.d (debug) and hardcoded "OkHttp" tag.

It split the log at newlines or when it reach the max length.

This class below is an helper class you can use (if you have lambda support throw Jack & Jill or retrolambda) to do the same thing OkHttp does on any log:

/**
* 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);
}
}

小开

Here is a Kotlin version for the @spatulamania answer (especially for lazy/smart peooples):

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

小开

I consider Timber a good option for this issue. Timber automatically split and print chunks of message in logcat.

https://github.com/JakeWharton/timber

You can see log method implementation in timber.log.Timber.DebugTree static class.

小开

if print json string, can use code below

    @JvmStatic
fun j(level: Int, tag: String? = null, msg: String) {
if (debug) {
if (TextUtils.isEmpty(msg)) {
p(level, tag, msg)
} else {
val message: String
message = try {
when {
msg.startsWith("{") -> {
val jsonObject = JSONObject(msg)
jsonObject.toString(4)
}
msg.startsWith("[") -> {
val jsonArray = JSONArray(msg)
jsonArray.toString(4)
}
else -> msg
}
} catch (e: JSONException) {
e.printStackTrace()
msg
}
p(level, tag, "╔═══════════════════════════════════════════════════════════════════════════════════════", false)
val lines = message.split(LINE_SEPARATOR.toRegex()).dropLastWhile { it.isEmpty() }.toTypedArray()
for (line in lines) {
p(level, tag, "║ $line", false)
}
p(level, tag, "╚═══════════════════════════════════════════════════════════════════════════════════════", false)
}
}
}

full code

CXLogUtil.j("json-tag","{}")

小开

For an easy solution, use Use soft wrap option in below attach point no 4 options might help you.

小开

With Kotlin we can make use of the stdlib chunked function:

fun logUnlimited(tag: String, string: String) {
val maxLogSize = 1000
string.chunked(maxLogSize).forEach { Log.v(tag, it) }
}

小开

        public static void largeLog(String tag, String content) {
final int SEG_LENGTH = 4000;
do {
if (content.length() <= SEG_LENGTH) {
Log.d(tag, content);
break;
}
Log.d(tag, content.substring(0, SEG_LENGTH));
content = content.substring(SEG_LENGTH);
} while (!content.isEmpty());
}