Logcat में लंबे संदेश कैसे प्रदर्शित करें


99

मैं लॉगकैट पर लंबे संदेश को प्रदर्शित करने का प्रयास कर रहा हूं। यदि संदेश की लंबाई 1000 वर्णों से अधिक है, तो वह टूट जाता है।

Logcat में लंबे संदेश के सभी वर्णों को दिखाने के लिए क्या तंत्र है?


6
मुझे सर्वर से लंबी स्ट्रिंग के रूप में प्रतिक्रिया मिल रही है।
वासु

1
फिर भी आप पूरे स्ट्रिंग को प्रिंट क्यों करना चाहते हैं, इसे एक फाइल या डेटाबेस में लिखें और वहां देखें - यदि यह डिबगिंग के लिए है
राहुल चौधरी

अपने लॉगकैट स्ट्रिंग को कॉपी करें और नोटपैड में अतीत, आप स्ट्रिंग की पूरी 1000 लंबाई देख सकते हैं।
इलंगो जे सेप

जवाबों:


149

यदि 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 () लेकिन यहां इसकी केवल आधी प्रतिक्रिया ही छपी है जब मैं लॉग बिल्ली में json परिणाम प्रिंट करता हूं
वासु

लेकिन iPhone कंसोल में मुझे पूरी प्रतिक्रिया स्ट्रिंग मिल रही है
वासु

आप लॉग को लंबाई () लिखकर प्रतिक्रिया की लंबाई की जांच कर सकते हैं। यदि यह मान वह नहीं है जिसकी आपको अपेक्षा थी, तो समस्या लॉगिंग के साथ नहीं हो सकती है।
स्पैटुलमनिया

3
विश्वास नहीं कर सकता कि Android इसे इतना कठिन बना देता है!
एलस्टन

1
मुझे लगता है कि यह कोड अंत में एक अतिरिक्त, खाली लॉग प्रविष्टि दर्ज करेगा, यदि veryLongString.length()एक से अधिक है maxLogSize। शायद <=करने के लिए बदल जाते हैं <
लार्स

29

स्पैटुलेमनिया उत्तर के अनुसरण के रूप में मैंने एक रैपर क्लास लिखी जो आपके लिए इसे संभालती है। आपको बस आयात बदलने की आवश्यकता है और यह सब कुछ लॉग करेगा

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

}

23

यह स्पैटुलानिया के उत्तर पर बनाता है, थोड़ा अधिक रसीला है, और अंत में एक खाली लॉग संदेश नहीं जोड़ेगा:

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

धन्यवाद। 3000 से अधिक प्रतीकों की सिफारिश नहीं की गई है, मैं इसका उपयोग करता हूं।
कूलमाइंड

9

इस तरह से 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);
    }
}

मैं खुद उनके कोड में तलाश कर रहा था लेकिन वह नहीं मिल रहा था। धन्यवाद।
बग्स

8

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

6
जब एक साधारण लूप पर्याप्त होगा, तो पुनरावृत्ति का उपयोग क्यों करें।
pellucide

3
मैं पुनरावृत्ति का प्रशंसक हूं क्योंकि मुझे कोड की महानता का पुन: उपयोग और पुन: उपयोग मिल रहा है। हालाँकि यह टेल एंड रिकर्स स्टैक फ्रेम को जल्दी से बना सकता है यदि आपका कंपाइलर उन्हें ऑप्टिमाइज़ नहीं करता है (जो मुझे विश्वास नहीं है कि एंड्रॉइड स्टूडियो एक करता है)। इसका मतलब यह है कि यदि आपके पास एक लंबा संदेश है जो पुनरावर्ती कॉल का एक प्ल्यूरियस का कारण बनता है तो आप आसानी से एक StackOverflowError बना सकते हैं।
ल्यूक

3

लॉग संदेशों में विभाजन लाइनों को कम करने के लिए नहीं, मैं बड़ी स्ट्रिंग लेता हूं और प्रत्येक पंक्ति को अलग से लॉग करता हूं।

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

1

यहाँ @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))
}

1

मैं टिम्बर को इस मुद्दे के लिए एक अच्छा विकल्प मानता हूं। इमारती लकड़ी स्वचालित रूप से विभाजित और लॉगकिट में संदेश का हिस्सा है।

https://github.com/JakeWharton/timber

आप timber.log.Timber.DebugTree स्थिर वर्ग में लॉग विधि कार्यान्वयन देख सकते हैं।


0

अगर प्रिंट करें 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-टैग", "{}")

पूर्वावलोकन परिणाम


-2

एक आसान समाधान के लिए, नीचे दिए गए बिंदु नंबर 4 में सॉफ्ट रैप विकल्प का उपयोग करें

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.