लॉगकैट

Question

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

लॉगकैट में लंबे संदेश के सभी पात्रों को दिखाने के लिए तंत्र क्या है?

Answer 1

अगर लॉगक 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)); 
} 

Answer 2

spatulamania जवाब देने के लिए पर

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

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

} 

Answer 3

प्रवेश करेंगे 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 
    } 
} 

Answer 4

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

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

Answer 5

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

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

Answer 6

यह है कि यह कैसे 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" टैग का उपयोग है।

यह लॉगलाइन को न्यूलाइन पर विभाजित करता है या जब यह अधिकतम लंबाई तक पहुंच जाता है।

नीचे इस वर्ग के एक सहायक वर्ग आप उपयोग कर सकते हैं एक ही बात OkHttp किसी भी लॉग पर करता है (यदि आप लैम्ब्डा समर्थन फेंक जैक & जिल या retrolambda है):

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

Answer 7

यहाँ एक Kotlin संस्करण है @spatulamania answer (विशेष रूप से के लिए आलसी/स्मार्ट 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)) 
} 

Answer 8

मैं इमारती लकड़ी इस समस्या के लिए एक अच्छा विकल्प पर विचार करें। Timber स्वचालित रूप से logcat में संदेश के टुकड़े विभाजित और मुद्रित करें।

https://github.com/JakeWharton/timber

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