मैं लॉगकैट पर लंबे संदेश को प्रदर्शित करने का प्रयास कर रहा हूं। यदि संदेश की लंबाई 1000 वर्णों से अधिक है, तो वह टूट जाता है।
Logcat में लंबे संदेश के सभी वर्णों को दिखाने के लिए क्या तंत्र है?
मैं लॉगकैट पर लंबे संदेश को प्रदर्शित करने का प्रयास कर रहा हूं। यदि संदेश की लंबाई 1000 वर्णों से अधिक है, तो वह टूट जाता है।
Logcat में लंबे संदेश के सभी वर्णों को दिखाने के लिए क्या तंत्र है?
जवाबों:
यदि logcat 1000 पर लंबाई कैप कर रहा है तो आप स्ट्रिंग को विभाजित कर सकते हैं जिसे आप String.subString () के साथ लॉग इन करना चाहते हैं और इसे टुकड़ों में लॉग कर सकते हैं। उदाहरण के लिए:
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));
}
veryLongString.length()
एक से अधिक है maxLogSize
। शायद <=
करने के लिए बदल जाते हैं <
।
स्पैटुलेमनिया उत्तर के अनुसरण के रूप में मैंने एक रैपर क्लास लिखी जो आपके लिए इसे संभालती है। आपको बस आयात बदलने की आवश्यकता है और यह सब कुछ लॉग करेगा
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));
}
}
}
यह स्पैटुलानिया के उत्तर पर बनाता है, थोड़ा अधिक रसीला है, और अंत में एक खाली लॉग संदेश नहीं जोड़ेगा:
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)));
}
इस तरह से HttpLoggingInterceptor के साथ OkHttp इसे करता है:
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
4000 है।
यहाँ यह Log.d (डीबग) और हार्डकोड "OkHttp" टैग का उपयोग करता है।
यह लॉग को नए सिरे पर विभाजित करता है या जब यह अधिकतम लंबाई तक पहुंच जाता है।
नीचे यह वर्ग एक सहायक वर्ग है जिसे आप उपयोग कर सकते हैं (यदि आपके पास लैम्ब्डा सपोर्ट थ्रो जैक एंड जिल या रेट्रोलंबा है) तो वही काम करें जो ओकेहटप किसी लॉग पर करता है:
/**
* 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);
}
}
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
}
}
लॉग संदेशों में विभाजन लाइनों को कम करने के लिए नहीं, मैं बड़ी स्ट्रिंग लेता हूं और प्रत्येक पंक्ति को अलग से लॉग करता हूं।
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));
}
}
यहाँ @spatulamania उत्तर के लिए एक कोटलिन संस्करण है (विशेष रूप से आलसी / स्मार्ट लोगों के लिए):
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))
}
मैं टिम्बर को इस मुद्दे के लिए एक अच्छा विकल्प मानता हूं। इमारती लकड़ी स्वचालित रूप से विभाजित और लॉगकिट में संदेश का हिस्सा है।
https://github.com/JakeWharton/timber
आप timber.log.Timber.DebugTree स्थिर वर्ग में लॉग विधि कार्यान्वयन देख सकते हैं।
अगर प्रिंट करें json स्ट्रिंग, नीचे दिए गए कोड का उपयोग कर सकते हैं
@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)
}
}
}
CXLogUtil.j ( "json-टैग", "{}")