Logcat'te uzun mesajlar nasıl görüntülenir


99

Logcat üzerinde uzun bir mesaj görüntülemeye çalışıyorum. Mesajın uzunluğu 1000 karakterden fazlaysa kırılır.

Uzun mesajın tüm karakterlerini logcat'te gösterme mekanizması nedir?


6
Sunucudan uzun bir dize olarak yanıt alıyorum.
Vasu

1
O zaman bile neden tüm dizeyi yazdırmak, bir dosyaya veya veritabanına yazmak ve orada görüntülemek - hata ayıklama için
Rahul Choudhary

logcat dizenizi kopyalayıp notpad'e yapıştırın, tam 1000 uzunlukta dizeyi görebilirsiniz.
ilango j

Yanıtlar:


151

Eğer logcat uzunluğu 1000 olarak sınırlıyorsa, o zaman günlüğe girmek istediğiniz dizeyi String.subString () ile bölebilir ve onu parçalara ayırabilirsiniz. Örneğin:

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

Log cat yanıtın sadece yarısını yazdırıyor .. tüm yanıtın uzunluğunu nasıl elde edebilirim. çokLongString.length () dediniz, ancak burada json sonucunu yazdırdığımda yanıtın yalnızca yarısı yazdırıldı
Vasu

Ancak iphone konsolunda tüm yanıt dizesini alıyorum
Vasu

günlüğe length () yazarak yanıtın uzunluğunu kontrol edebilirsiniz. Bu değer beklediğiniz gibi değilse, sorun günlüğe kaydetmeyle ilgili olmayabilir.
spatulamania

3
Android'in bunu bu kadar zorlaştırdığına inanamıyorum!
Alston

1
Sanırım bu kod, eğer veryLongString.length()birden fazla ise , sonunda fazladan boş bir günlük girişi kaydedecektir maxLogSize. Belki değiştirmek <=için <.
LarsH

30

Spatulamania cevabının devamı olarak, bunu sizin için ele alan bir paketleyici sınıfı yazdım. İçe aktarımı değiştirmeniz yeterlidir ve her şeyi günlüğe kaydedecektir.

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

}

24

Bu, spatulamania'nın cevabına dayanıyor, biraz daha özlü ve sonuna boş bir günlük mesajı eklemeyecek:

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

Teşekkürler. 3000'den fazla sembol tavsiye edilmiyor, ben öyle kullanıyorum.
CoolMind

9

HttpLoggingInterceptor ile OkHttp bunu şu şekilde yapar:

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'dir.

Burada Log.d (hata ayıklama) ve kodlanmış "OkHttp" etiketini kullanır.

Günlüğü satır başlarında veya maksimum uzunluğa ulaştığında böler.

Aşağıdaki bu sınıf, OkHttp'nin herhangi bir günlükte yaptığı aynı şeyi yapmak için kullanabileceğiniz yardımcı bir sınıftır (lambda support throw Jack & Jill veya retrolambda varsa):

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

Kodlarında kendim arıyordum ama bulamadım. Teşekkür ederim.
Hatalar

8

Logcat'te uzun mesaj göstermek için bu kod parçasını deneyin.

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

7
basit bir döngü yeterli olduğunda, neden özyineleme kullanalım.
pellucide

3
Kodun okunabilirliğini ve yeniden kullanımını harika bulduğum için özyineleme hayranıyım. Bununla birlikte, bu kuyruk sonu özyineleme, derleyiciniz onları optimize etmezse (Android stüdyosunun yaptığına inanmıyorum) yığın çerçevelerini hızlı bir şekilde oluşturabilir. Bu, özyinelemeli çağrıların çoğulmasına neden olan büyük ölçüde uzun bir mesajınız varsa, kolayca bir StackOverflowError oluşturabileceğiniz anlamına gelir.
Luke

3

Satırları günlük mesajlarında bölmeyi en aza indirmemek için, büyük dizeyi alıp her satırı ayrı ayrı günlüğe kaydediyorum.

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

İşte @spatulamania yanıtı için bir Kotlin sürümü (özellikle tembel / akıllı insanlar için):

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

Kereste'yi bu sorun için iyi bir seçenek olarak görüyorum. Timber, logcat'te mesaj parçalarını otomatik olarak böler ve yazdırır.

https://github.com/JakeWharton/timber

Timber.log.Timber.DebugTree statik sınıfında günlük yöntemi uygulamasını görebilirsiniz.


0

json dizesi yazdırırsanız, aşağıdaki kodu kullanabilir

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

tam kod

CXLogUtil.j ("json-etiketi"; "{}")

önizleme sonucu


-3

Kolay bir çözüm için, aşağıdaki 4 numaralı bağlantı noktasında yumuşak sarma seçeneğini kullanın seçeneği size yardımcı olabilir.

Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.