android-studio - Android studio logcat 没什么可显示的

Question

我昨天安装了 Android Studio，并尝试使用 LogCat 查看日志。但是在 logcat 中没有什么可显示的。我使用终端运行./adb logcat并且它可以工作。

有人可以向我解释如何在 Android Studio 中使用 logcat 吗？

Answer 1

重新启动 logcat 总是对我有帮助。

Answer 2

我经常进入这种状态。Logcat 为空白。调试工作，我可以打断点。没有设置过滤器。日志级别为详细。我通过反复循环以下内容来修复它：

• 重启 logcat（见上面 Zatziky 的回答）
• 将日志级别更改为调试（或其他任何内容）并返回详细。
• 拔出和重新插入设备
• 跑步adb kill-server && adb start-server
• 关闭 Android Studio 并ddms在命令行上启动。
• 重启 Android Studio

如果一切都失败了，最后重新启动计算机。

问题是间歇性的，我认为 Android Studio 只是错误。

Answer 3

我有同样的问题，但我通过以下步骤解决了，试试这个。

1）在安卓工作室。

2）打开android Monitor窗口（android studio底部）

3）您可以在右上角看到下拉菜单（微调器）

4) 选择 -仅显示选定的应用程序。

Answer 4

您需要按两次Alt+重新启动 logcat 窗口。6这样它就会显示日志输出。

该问题主要发生在调试模式下。

Answer 5

修复一些不必要的更改的最佳方法是使缓存无效

转到 FILE -> 单击“INVALIDATE CACHES/RESTART”，然后会弹出一个对话框，选择“INVALIDATE CACHES/RESTART”按钮。

Android Studio 会自动重启并重建索引。

Answer 6

这些帮助了我：

1.启用 ADB 集成 2.转到 Android 设备监视器检查您的设备是否在线并创建所需的过滤器

Answer 7

在终端中运行此命令。它将再次开始工作。

adb kill-server && adb start-server

Answer 8

在 android Studio 应用程序中，您需要单击调试应用程序选项 (Shift+f9) 以在调试模式下运行并启用 LogCat。

Answer 9

重新启动 Android Studio 帮助了我。

Answer 10

不是技术答案，但您可能需要检查 logcat 的搜索框。如果输入了任何字符，您的 logcat 将为空，因为它将搜索该特定字符或单词，然后如果它不存在，您的 logcat 日志将完全为空。

Answer 11

确保您的模拟器开发人员菜单选项中有 Logger 缓冲区大小属性值。

Answer 12

对我来说，问题是我有两个同名的模拟器（我创建它，删除它，然后用同名再次创建它）。logcat 下拉列表中有两个模拟器条目，它连接到错误的条目。我所要做的就是切换到另一个。我通过重命名模拟器永久地防止了这个问题。

Answer 13

**

• 如果您仍然坚持 logcat 为空，请阅读此内容

**

经过几个月的烦恼和麻烦，我刚刚解决了这个问题。
没有任何帮助，设备监视器在调试期间工作正常，但标准 logcat 视图始终为空。

原因非常简单：
logcat 视图在那里，但它已被更新移动到 0 宽度！

您在“ALT 6”选项卡中，您会在其中看到两个选项卡“ADB 日志”和“设备 | logcat”
设备 | logcat 真正意味着它由设备和 logcat 组成，由垂直边框分隔。
垂直边框可以移动，并且在更新期间它似乎已移动到 100% 正确。

这会导致 logcat 被收集但不显示，将鼠标指针移动到工具窗口的右侧，然后将 logcat 拖回到视图中。

这个解决方案对每个人都没有帮助，但我发现很多人都在使用 ADB 连接，但仍然没有 logcat 输出，这些人可能会遇到同样的问题。

Answer 14

---

尝试关闭项目并重新打开它。它对我有用。日志将重新出现。

Answer 15

就我而言，我从右侧的小下拉列表中删除了“图像”。在那之后它显示得很好。那是因为它将在该搜索框中搜索关键字的日志，因此如果找不到任何匹配项，则返回空白

Answer 16

即使在最新版本的 Android Studio 上仍然遇到这个问题，这很奇怪。我通读了一长串解决方案，但它们对我不起作用。接受的答案适用于早期版本的 Android Studio（我猜它是 v2.3）

我做了以下让 Logcat 再次工作：

1. Logcat > 仅显示选定的应用程序 > 无过滤器

2. Logcat > 无过滤器 > 仅显示选定的应用程序

我希望重置 logcat 理想情况下应该会给我同样的效果，但事实并非如此。手动切换过滤器是唯一有效的方法。

这是在Android Studio 3.0.1（稳定版）上（我无法在完成当前项目之前对其进行更新）当我早上启动Android Studio以继续我晚上离开的工作时出现问题。我希望开发人员会对此进行调查。尝试了超过 15 种来自 stackoverflow 的解决方案，但仍然看不到任何结果。为这个问题的未来受害者揭示另一种解决方案甚至令人恼火。

Answer 17

就我而言，在开发人员选项菜单中有一个名为

Revoke USB debugging authorisations.

一旦您撤销所有现有授权，它会再次要求信任您正在使用的计算机，之后它会再次开始显示日志。

Answer 18

当其他一切都不起作用时，这就是我所做的。由于adb logcat工作得很好，我决定依靠它。在 Android Studio 的嵌入式终端中运行adb logcat -v color会产生类似于普通 logcat 的输出，并且允许代码链接也可以工作：

但这带来了一些问题：

• 您不能指定要观看的包。使用该--pid=<your PID>选项，您可以查看单个进程的输出。但是由于每次重新启动应用程序时 PID 都会发生变化，因此每次重新启动时都会重新运行此命令。
• 颜色很烦人（在我看来）。
• 输出字段与之前的消息不一致，整个内容的格式不正确，这使得跟踪 logcat 比它应该做的要困难得多（不过，嵌入式 logcat 也会发生同样的情况）。

所以我决定制作自己的工具来自动监视我的包 PID 并美化 logcat 输出：

import java.awt.AWTException;
import java.io.*;
import java.util.ArrayList;
import java.awt.Robot;
import java.awt.event.KeyEvent;

public class Logcat {

    private static final String ADB_FILE_PATH = "adb";

    // Customizations,
    private static final Color     V_COLOR = Color.RESET;
    private static final Color     D_COLOR = Color.RESET;
    private static final Color     I_COLOR = Color.RESET;
    private static final Color     W_COLOR = Color.BLUE;
    private static final Color     E_COLOR = Color.RED_BRIGHT;
    private static final Color  HINT_COLOR = Color.MAGENTA_BOLD_BRIGHT;
    private static final Color OTHER_COLOR = Color.GREEN_BOLD_BRIGHT;

    private static final int       DATE_LENGTH =   5;
    private static final int       TIME_LENGTH =  12;
    private static final int PROCESS_ID_LENGTH =   5;
    private static final int  THREAD_ID_LENGTH =   5;
    private static final int  LOG_LEVEL_LENGTH =   1;
    private static final int        TAG_LENGTH =  20;
    private static final int    MESSAGE_LENGTH = 110;

    private static final String SEPARATOR = " | ";
    private static final String CONTINUATION = "→";
    private static final String INDENTATION = "  ";

    private static final int PROCESS_IDS_UPDATE_INTERVAL_MILLIS = 1224;

    private static final int HISTORY_LENGTH = 1000;

    // State,
    private static boolean skipProcessIDCheck;
    private static ArrayList<String> processIDs = new ArrayList<String>();

    private static String logLevelToShow="V";  // All.

    private static Process logcatProcess;
    private static boolean appClosed;
    private static boolean stopEverything;

    private static String[] history = new String[HISTORY_LENGTH];
    private static int currentLocationInHistory, historyLength;

    public static void main(final String args[]) {

        clearAndroidStudioConsole();
        System.out.println("besm Allah");

        // Get processes ids of the provided package,
        if (args.length==0) {
            skipProcessIDCheck = true;
        } else {
            skipProcessIDCheck = false;
            getProcessIDs    (args[0]);    // Do it once before we start.
            monitorProcessIDs(args[0]);    // Do it periodically from now on.
        }

        // Start capturing and prettifying logcat,
        if (!monitorLogcat()) {
            stopEverything = true;
            return;
        }

        // Handle user input,
        handleUserInput();
    }

    private static void watch(final Process process, final ProcessListener listener) {

        // Read process standard output and send it to the listener line by line,
        new Thread() {
            public void run() {
                BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(process.getInputStream()));
                String line = "";
                try {
                    do {
                        if (bufferedReader.ready()) {
                            line = bufferedReader.readLine();
                            if (line!=null && !line.isEmpty()) listener.onNewLine(line);
                        } else {
                            Thread.sleep(100);
                        }
                    } while (line!=null && !stopEverything);
                } catch (Exception e) { e.printStackTrace(); }
            }
        }.start();
    }

    private static void monitorProcessIDs(String packageName) {

        // Continuously monitor the process IDs of this package and update when changed,
        new Thread() {
            public void run() {
                do {
                    try { Thread.sleep(PROCESS_IDS_UPDATE_INTERVAL_MILLIS); } catch (InterruptedException e) {}
                    getProcessIDs(packageName);
                } while (!stopEverything);
            }
        }.start();
    }

    private static void getProcessIDs(String packageName) {

        // Get the process IDs associated with this package once,
        ArrayList<String> newProcessIDs = new ArrayList<String>();
        Runtime runtime = Runtime.getRuntime();
        try {
            Process getPIDProcess = runtime.exec(ADB_FILE_PATH + " shell ps");
            watch(getPIDProcess, (line) -> {
                if (line.contains(packageName)) {
                    newProcessIDs.add(removeRedundantSpaces(line).split(" ")[1]);
                }
            });
            getPIDProcess.waitFor();
            Thread.sleep(500);  // Make sure we've already handled all the input from the process.
        } catch (Exception e) { e.printStackTrace(); }

        // Return immediately if program is closed,
        if (stopEverything) return ;

        // Some action upon getting the pid(s),
        boolean shouldRepeatHistory = false;
        if (newProcessIDs.isEmpty()) {

            // Just closed,
            if (!appClosed) {
                appClosed = true;
                prettify("----- App closed -----");
            }
        } else if (appClosed) {

            // Just opened, clear,
            appClosed = false;
            clearAndroidStudioConsole();
            prettify("----- App opened -----");
            shouldRepeatHistory = true;
        } else {

            // Detect changes in processes,
            for (String pid : newProcessIDs) {
                if (!processIDs.contains(pid)) {
                    clearAndroidStudioConsole();
                    prettify("----- Process(es) changed (or app restarted - some logs could have been missed) -----");
                    shouldRepeatHistory = true;
                    break ;
                }
            }
        }

        // Set the new PID(s),
        processIDs = newProcessIDs;
        if (shouldRepeatHistory) repeatHistory();
    }

    private static boolean monitorLogcat() {

        Runtime runtime = Runtime.getRuntime();
        try {
            logcatProcess = runtime.exec(ADB_FILE_PATH + " logcat -v threadtime");
            watch(logcatProcess, (line) -> {

                // Learn history, in case we need to repeat it,
                if (appClosed || processLogcatLine(line)) {
                    history[currentLocationInHistory] = line;
                    currentLocationInHistory = (currentLocationInHistory + 1) % history.length;
                    if (historyLength<history.length) historyLength++;
                }
            });
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }

        return true;
    }

    private static boolean processLogcatLine(String line) {
        try {
            return prettify(line);
        } catch (Exception e) {
            print(line, OTHER_COLOR);
            System.out.println();

            // Debug,
            e.printStackTrace();
            return true;
        }
    }

    // Returns true if line should be kept in history,
    private static synchronized boolean prettify(String line) {

        if (line.startsWith("-")) {
            // It's a "beginning of <something>" line,
            print(line, HINT_COLOR);
            System.out.println();
            return true;
        }

        // Get the individual fields,
        String      date = line.substring(0, line.indexOf(' ')); line = line.substring(line.indexOf(' ')+1); line = line.trim();
        String      time = line.substring(0, line.indexOf(' ')); line = line.substring(line.indexOf(' ')+1); line = line.trim();
        String processID = line.substring(0, line.indexOf(' ')); line = line.substring(line.indexOf(' ')+1); line = line.trim();

        // Break early if possible,
        if (!skipProcessIDCheck && !processIDs.contains(processID.trim())) return false;

        // Continue parsing,
        String  threadID = line.substring(0, line.indexOf(' ')); line = line.substring(line.indexOf(' ')+1); line = line.trim();
        String  logLevel = line.substring(0, line.indexOf(' ')); line = line.substring(line.indexOf(' ')+1); line = line.trim();

        // Break early if possible,
        switch (logLevel) {
            case "V": if (!"V"    .contains(logLevelToShow)) return true; break;
            case "D": if (!"VD"   .contains(logLevelToShow)) return true; break;
            case "I": if (!"VDI"  .contains(logLevelToShow)) return true; break;
            case "W": if (!"VDIW" .contains(logLevelToShow)) return true; break;
            case "E": if (!"VDIWE".contains(logLevelToShow)) return true; break;
        }

        // Continue parsing,
        String       tag = line.substring(0, line.indexOf(':')); line = line.substring(line.indexOf(':')+1); line = line.trim();

        // Because some tags have a trailing ":",
        if (line.startsWith(":")) {
            tag += ":";
            line = line.substring(1);
        }

        // Indent lines starting by "at",
        String indentation = "";
        if (line.startsWith("at ")) {
            indentation = "   " + INDENTATION;
            line = " " + INDENTATION + line;
        }

        // Print the prettified log,
        Color color;
        switch (logLevel) {
            case "V": color = V_COLOR; break;
            case "D": color = D_COLOR; break;
            case "I": color = I_COLOR; break;
            case "W": color = W_COLOR; break;
            case "E": color = E_COLOR; break;
            default:
                color = Color.RESET;
        }

        String fields = adjustLength(     date,       DATE_LENGTH) + SEPARATOR +
                        adjustLength(     time,       TIME_LENGTH) + SEPARATOR +
                        adjustLength(processID, PROCESS_ID_LENGTH) + SEPARATOR +
                        adjustLength( threadID,  THREAD_ID_LENGTH) + SEPARATOR +
                        adjustLength( logLevel,  LOG_LEVEL_LENGTH) + SEPARATOR +
                        adjustLength(      tag,        TAG_LENGTH) + SEPARATOR;

        // Split the message onto multiple lines if needed,
        String message = chunkPreservingParentheses(line, MESSAGE_LENGTH, 2);
        print(fields + message, color);
        System.out.println();

        while (line.length() > message.length()) {

            // Debug,
            //print(line, OTHER_COLOR);
            //System.out.println("Line: " + line.length() + "length: " + message.length() + ", cont: " + CONTINUATION.length() + "dent: " + indentation.length());
            //System.out.println();

            // Remove the already printed part.
            line = line.substring(message.length()-CONTINUATION.length());

            // Add a dot to make links work,
            boolean shouldAddDot=false;
            if (line.matches("^[^\\.]*\\(.*:[123456789][1234567890]*\\).*")) shouldAddDot = true;

            // Indent,
            line = (shouldAddDot ? "." : (indentation.isEmpty() ? "" : " ")) + indentation + line;

            // Take another chunk,
            message = chunkPreservingParentheses(line, MESSAGE_LENGTH, 2+indentation.length());

            // Front pad to align this part with the message body,
            String paddedMessage = message;
            for (int i=0; i<fields.length(); i++) paddedMessage = ' ' + paddedMessage;

            // Print,
            print(paddedMessage, color);
            System.out.println();
        }

        return true;  // Keep in local buffer.
    }

    private static String adjustLength(String text, int length) {
        while (text.length() < length) text += ' ';
        if (text.length() > length) {
            text = text.substring(0, length-CONTINUATION.length());
            text += CONTINUATION;
        }
        return text;
    }

    private static String chunkPreservingParentheses(String text, int length, int minChunckLength) {

        if (text.length() <= length) return text;

        // Take a chunk out of the text,
        String chunk = text.substring(0, length-CONTINUATION.length()) + CONTINUATION;

        // Check if a paranthesis was opened and not closed,
        int lastOpenParanthesisIndex = chunk.lastIndexOf('(');
        int lastCloseParanthesisIndex = chunk.lastIndexOf(')');
        if (lastCloseParanthesisIndex <= lastOpenParanthesisIndex) {  // Also works when either is not found.
            if (minChunckLength<1) minChunckLength = 1;
            if (lastOpenParanthesisIndex > minChunckLength+CONTINUATION.length()) { // Avoid endless loops.
                int includeParenthesisSize = (CONTINUATION.length()>0) ? 1 : 0;
                chunk = text.substring(0, lastOpenParanthesisIndex+includeParenthesisSize-CONTINUATION.length()) + CONTINUATION;
            }
        }

        return chunk;
    }

    private static void repeatHistory() {
        int index = currentLocationInHistory-historyLength;
        if (index < 0) index += history.length;
        for (int i=0; i<historyLength; i++) {
            processLogcatLine(history[index]);
            index = (index + 1) % history.length;
        }
    }

    private static void print(String text, Color color) {
        System.out.print(color);
        System.out.print(text);
        System.out.print(Color.RESET);
    }

    private static String removeRedundantSpaces(String text) {
        String newText = text.replace("  ", " ");
        while (!text.equals(newText)) {
            text = newText;
            newText = text.replace("  ", " ");
        }
        return text;
    }

    private static void clearAndroidStudioConsole() {

        // Couldn't find a reliable way to clear Intellij terminal scrollback, so we just print
        // a LOT of newlines,
        StringBuilder bunchOfNewLines = new StringBuilder();
        for (int i=0; i<124; i++) bunchOfNewLines.append(System.lineSeparator());
        System.out.print(bunchOfNewLines);

        // Scroll the current line to the top of the window,
        try {
            // If we are on Windows,
            new ProcessBuilder("cmd", "/c", "cls").inheritIO().start().waitFor();
        } catch (Exception e) {

            // We are not on Windows,
            bunchOfNewLines = new StringBuilder();
            for (int i=0; i<124; i++) bunchOfNewLines.append("\b\r");
            System.out.print(bunchOfNewLines);
        }
    }

    private static void handleUserInput() {

        // Line read. Unfortunately, java doesn't provide character by character reading out of the box.
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        String input = "";
        do {
            try {
                if (bufferedReader.ready()) {
                    input = input = bufferedReader.readLine().toUpperCase();

                    // Set log level,
                    if (input.equals("V")||input.equals("D")||input.equals("I")||input.equals("W")||input.equals("E")) {

                        if (!logLevelToShow.equals(input)) {
                            logLevelToShow = input;
                            clearAndroidStudioConsole();
                            repeatHistory();
                        }

                        prettify("----- Log level set to " + logLevelToShow + " -----");

                    } else if (input.equals("C")) {

                        // Clear screen and history,
                        clearAndroidStudioConsole();
                        historyLength = 0;
                    }
                } else {
                    Thread.sleep(100);
                }
            } catch (Exception e) { e.printStackTrace(); }

            // Check if the logcat process is still alive,
            if (!logcatProcess.isAlive()) {
                prettify("----- adb logcat process terminated -----");
                stopEverything = true;
            }

        } while (!stopEverything && !input.equals("Q"));

        // Allow all monitoring threads to exit,
        stopEverything = true;
    }

    interface ProcessListener {
        void onNewLine(String line);
    }

    enum Color {

        // Thanks to this answer: https://stackoverflow.com/a/51944613/1942069

        //Color end string, color reset
        RESET("\033[0m"),

        // Regular Colors. Normal color, no bold, background color etc.
        BLACK  ("\033[0;30m"),
        RED    ("\033[0;31m"),
        GREEN  ("\033[0;32m"),
        YELLOW ("\033[0;33m"),
        BLUE   ("\033[0;34m"),
        MAGENTA("\033[0;35m"),
        CYAN   ("\033[0;36m"),
        WHITE  ("\033[0;37m"),

        // Bold
        BLACK_BOLD  ("\033[1;30m"),
        RED_BOLD    ("\033[1;31m"),
        GREEN_BOLD  ("\033[1;32m"),
        YELLOW_BOLD ("\033[1;33m"),
        BLUE_BOLD   ("\033[1;34m"),
        MAGENTA_BOLD("\033[1;35m"),
        CYAN_BOLD   ("\033[1;36m"),
        WHITE_BOLD  ("\033[1;37m"),

        // Underline
        BLACK_UNDERLINED  ("\033[4;30m"),
        RED_UNDERLINED    ("\033[4;31m"),
        GREEN_UNDERLINED  ("\033[4;32m"),
        YELLOW_UNDERLINED ("\033[4;33m"),
        BLUE_UNDERLINED   ("\033[4;34m"),
        MAGENTA_UNDERLINED("\033[4;35m"),
        CYAN_UNDERLINED   ("\033[4;36m"),
        WHITE_UNDERLINED  ("\033[4;37m"),

        // Background
        BLACK_BACKGROUND  ("\033[40m"),
        RED_BACKGROUND    ("\033[41m"),
        GREEN_BACKGROUND  ("\033[42m"),
        YELLOW_BACKGROUND ("\033[43m"),
        BLUE_BACKGROUND   ("\033[44m"),
        MAGENTA_BACKGROUND("\033[45m"),
        CYAN_BACKGROUND   ("\033[46m"),
        WHITE_BACKGROUND  ("\033[47m"),

        // High Intensity
        BLACK_BRIGHT  ("\033[0;90m"),
        RED_BRIGHT    ("\033[0;91m"),
        GREEN_BRIGHT  ("\033[0;92m"),
        YELLOW_BRIGHT ("\033[0;93m"),
        BLUE_BRIGHT   ("\033[0;94m"),
        MAGENTA_BRIGHT("\033[0;95m"),
        CYAN_BRIGHT   ("\033[0;96m"),
        WHITE_BRIGHT  ("\033[0;97m"),

        // Bold High Intensity
        BLACK_BOLD_BRIGHT  ("\033[1;90m"),
        RED_BOLD_BRIGHT    ("\033[1;91m"),
        GREEN_BOLD_BRIGHT  ("\033[1;92m"),
        YELLOW_BOLD_BRIGHT ("\033[1;93m"),
        BLUE_BOLD_BRIGHT   ("\033[1;94m"),
        MAGENTA_BOLD_BRIGHT("\033[1;95m"),
        CYAN_BOLD_BRIGHT   ("\033[1;96m"),
        WHITE_BOLD_BRIGHT  ("\033[1;97m"),

        // High Intensity backgrounds
        BLACK_BACKGROUND_BRIGHT  ("\033[0;100m"),
        RED_BACKGROUND_BRIGHT    ("\033[0;101m"),
        GREEN_BACKGROUND_BRIGHT  ("\033[0;102m"),
        YELLOW_BACKGROUND_BRIGHT ("\033[0;103m"),
        BLUE_BACKGROUND_BRIGHT   ("\033[0;104m"),
        MAGENTA_BACKGROUND_BRIGHT("\033[0;105m"),
        CYAN_BACKGROUND_BRIGHT   ("\033[0;106m"),
        WHITE_BACKGROUND_BRIGHT  ("\033[0;107m");

        private final String code;

        Color(String code) { this.code = code; }
        @Override public String toString() { return code; }
    }
}

只需将此代码转储到Logcat.java并使用以下命令进行编译：

javac Logcat.java

并在 Android Studio 的嵌入式终端中运行：

java Logcat <your.package.name>

例如：

java Logcat com.nomone.vr_desktop

结果如下所示：

它是高度可定制的，我在应用程序的第一部分中分离了大部分选项，因此您可以轻松调整颜色和格式。如果该adb工具不在您的 PATH 环境变量中，只需ADB_FILE_PATH在编译之前在变量中（在代码中）设置其完整路径。

当应用程序运行时，您可以键入以下快捷方式：

• c清除屏幕和本地缓冲区。
• v, i, d, w,e更改 logcat 级别。
• q优雅地退出。Ctrl+c也可以。

不幸的是，您必须enter在按下这些键后按下。似乎Java不允许在不编写系统特定代码的情况下从控制台输入单个字符。对不起！

免责声明

• 如果使用 adb 连接了多个设备，这将不起作用。
• 我还没有彻底测试过这个。我只在一些设备上使用了一段时间。
• 我没有在 Windows 或 Mac 上测试过这个，但我尽量避免使用任何系统特定的东西，所以它应该仍然可以工作。

我希望这能解决你的问题:)

Answer 19

In Android 3.6.1 I had to:

• Upgrade to latest Android Studio version (4.x.x)
• Restart Logcat
• Restart the app
• Restart Android Studio
• Restart the Android testing device

Answer 20

在“Devices logcat”选项卡的右侧，有一个“Show only Logcat from selected Process”按钮。它并不完美，因为每次我运行另一个进程时，我都需要再次推送它，但这是唯一适合我的解决方案。至今...

Answer 21

这可能不是您的问题，但我发现当打开多个 Android Studio 窗口时，logcat 仅定向到其中一个，而不一定是运行活动应用程序的那个。

例如，窗口 1 是我开发井字游戏应用程序的地方，窗口 2 是我开发天气应用程序的地方。如果我在调试模式下运行天气应用程序，则可能只有窗口 1 能够显示 logcat 条目。

Answer 22

第 1 步：在 Android 开发者选项开启和 USB 调试开启的情况下连接您的手机。

第 2 步：转到View > Tools Window > Logcat

第 3 步：在运行项目之前确保您的手机连接 Android Studio。然后运行应用程序

注意：如果您无法显示 Logcat，只需重新启动 Android Studio：File > Invalid Caches/ restart

Answer 23

对我来说，问题是设备以该Charge only模式连接。

将模式更改为Media device (MTP)（或Transfer files在某些设备中）解决了问题。

Answer 24

在 Android Studio 0.8.0 中，您应该在运行应用程序之前通过 Tools -> Android 启用 ADB 集成。然后日志猫将正常工作。请注意，如果您在应用程序运行时禁用 ADB 集成并再次启用它，那么除非您重建项目，否则 log cat 不会显示任何内容。

Answer 25

我的问题解决了，在我 在AndroiManifest.xml的应用程序下添加android:debuggable="true"之后（甚至 ide 标记为错误的语法！？？？？）

Answer 26

就我而言，我刚刚过滤了输出，因此即使在重新启动 Logcat 等后它也显示为空。

Answer 27

我检查了答案，只是在检查我的 logcat 时意外发现了我的错误。确保右侧的框显示“仅显示选定的应用程序”。我的显示“Firebase”，所以它显示了来自 Firebase 的消息。

Answer 28

在 Android Studio 0.8.9 中，我打开了Android Device Monitor，从Devices列表中选择了我的模拟器，并在LogCat选项卡中获得了输出。

之后，我回到 Android Studio 的主视图并选择了Android DDMS选项卡右侧的Restore Logcat 视图，它就在那里！

如果这不起作用，您可以在Android 设备监视器中看到您的 logcat，正如我在第一句中解释的那样。

Answer 29

确保您正在导入正确的类

import android.util.Log;

Answer 30

我刚把它固定在我的身上。在 DDMS 显示屏的最右侧寻找可以恢复 Devices Logcat 视图和 ADB 视图的小图标。

当 DDMS 首次提出“ADB Logs”和“Devices | logcat”选项卡时。“Devices | logcat”是应该显示设备输出的那个，但它是空白的。不知何故，我设法隐藏了这些选项卡中的一个或另一个，我忘记了到底是如何隐藏的。但是，在右边有一个小图标，上面写着“Restore ADB”视图，我点击它，它就出现了。然后是另一个小图标，上面写着“Restore Devices logcat view”。我单击它，突然它出现并再次显示设备输出。

Answer 31

今天有同样的问题。

显然我也运行了 eclipse，所有的 logcat 输出都被重定向到了 eclipse。由于日志只能一次显示，请确保您没有运行多个调试器。

Answer 32

1. 首先确保在您的设备中启用了开发者选项。
2. 设备已连接。
3. 冗长。
4. 仅显示选定的应用程序。

Answer 33

我在使用模拟器时偶尔会遇到这种情况。我只需插入设备并运行应用程序。Logcat 重新开始工作，当我回到模拟器时也是如此。我想只需切换两个设备和/或模拟器也可以解决问题。

Answer 34

还要小心这个坏男孩（即使 android studio 的重启没有消失）：

Answer 35

全核解决方案。仅在尝试其他所有方法后使用它，因为这将删除您的所有设置和首选项以及存储的图像以及使您的模拟器运行的所有内容，直到您重新安装和重新配置。就我而言，这两个步骤都需要大约 20 分钟，因为除了使用 Darcula 之外，我没有进行太多自定义。

1. 删除您的 .AndroidStudioBeta 配置文件目录

对于 linux 用户，可以在 /home/[username]/.AndroidStudioBeta 下找到。
对于 windows 用户，我不确定。在我看来，它的文档相当模糊。可能在 C:\Users[你的用户]\Application Data 下的某个地方

2. 检查它是否有效，如果没有，则还要重新安装 SDK。

相当激烈，但我尝试了此页面上的所有其他内容，连接设备，没有过滤器，重新启动服务，此页面上的所有内容，但它没有工作。

Answer 36

对我来说，它不仅仅适用于我的应用程序，它正在工作，如果没有选择过滤器（右侧的选项）。但是我只需要查看我的应用程序，因此我发现，如果我自己进行过滤并将其过滤为包名称，它就会正常工作。我希望它也能对你有所帮助:)

Answer 37

Logcat 在 logcat 的右侧有一个小图标。您可以使用该图标来打开和关闭 logcat。我通常可以通过单击图标（可能多次）使 logcat 处于活动状态。

Answer 38

转到运行->调试如果您与主机失去连接，它将请求重新连接的权限。单击是。那应该这样做。

Answer 39

我有同样的症状，但我的问题更简单，真的是我的错误。我设置了错误的过滤器。

解决方案只是验证我是否设置了正确的过滤器。

Answer 40

对我有用的简单修复（在尝试了其他一些建议之后）。我的 logcat 在一个单独的窗口中（在我的第二个屏幕上）是空白的。只需将 Logcat 选项卡拖回它在调试器和控制台选项卡旁边的调试面板中的原始位置，然后瞧……它立即开始更新并显示所有进程的详细信息。因此（如果您的 logcat 位于调试器面板之外的任何位置（即 logcat 选项卡没有嵌套在调试器和控制台选项卡旁边），那么它将不会接收更新并且会空白地坐在那里。不知道这是否是旧版本的 Android Studio 的问题。但同样，很容易尝试，如果它有效......它有效！

Answer 41

我刚刚更改了applictionIdlogcat 停止工作。要重置它，您必须更改包名称。只需单击 Logcat 窗口中显示您的应用程序包名称的右上角下拉菜单，然后单击它，然后单击Edit Filter Configuration现在更改包名称。它将开始工作。

Answer 42

尝试@Robert Karl 在此线程中提到的要点。如果没有任何效果，那么您肯定可以通过 android 设备监视器查看日志。

1. 启动安卓设备监视器

2. 选择 DDMS 视角，

3. 然后选择您的设备，如屏幕截图所示。

   您可以根据您的要求应用过滤器

Answer 43

确保您已在 Build Variants 上下文菜单中启用构建变体以“调试”。（您可以在窗口的左下角找到它）。如果您之前已为应用程序签署了 apk，则此选项将设置为发布模式。这会导致调试消息不显示在日志 cat 中。

Answer 44

尝试单击“Android”视图最右侧的图标，您应该会在 Android 视图上看到 Logcat 选项卡（您可以通过按 Alt+6 调出 Android 视图）

Answer 45

重新启动我正在测试的手机解决了这个问题。

我使用的是带有 Android 6 的旧 LG4。

我尝试再次拔掉插头，重新启动 Android Studio，重新启动 logcat，使缓存无效 - 没有任何效果。

Answer 46

我尝试了上面的建议。然而，他们都没有工作。然后我做了以下令人惊讶的工作：

1. 断开 USB 与设备的连接
2. 使用命令通过 Wi-Fi 连接设备，adb tcpip 5555然后adb connect <device ip>
3. 使用断开设备与 adb 的连接adb kill-server
4. 通过 USB 重新连接设备

LogCat 然后显示日志。即使日志在步骤 2 中可用，以下步骤为我解决了通过 USB 连接时的问题。

Answer 47

某些自定义 rom 出于性能原因禁用日志记录（尽可能挤压 %） 检查您的 rom 的内置应用程序或调整 rom 的菜单以启用此功能。

我在 i9505 上运行 Kushan 的 Galaxy S4 Rom，我不知道它默认禁用日志记录以获得最微小的性能提升，但显然这在定制的“性能”导向 rom 上并不少见.. 我花了很长时间才发现这一点 - 非常烦人，因为它会告诉我记录了多少条消息，而不是它们的详细信息。

Answer 48

如果您同时使用超过 1 个版本的 adb，Logcat 可能会失败。一个在 Android Studio 中，一个在终端中。

您可能有不同版本的 adb：“sudo apt-get install android-tools-adb”，它将创建 /usr/bin/adb 包含 {android-sdk}/platform-tools/adb 的 Android SDK，或者来自创建 out/host/linux-x86/bin/adb 的 AOSP 构建的输出

要查看此问题是否影响您，请使用“Help -> Show Log in Files”打开idea.log，然后查找“Initializing adb using:/home/repkap11/android-sdk/platform-tools/adb”之类的行。将此路径与终端中的“which adb”进行比较。如果它们不匹配，则此问题会影响您。

Android Studio 寻找 {android-sdk}/platform-tools/adb 并且不关心您的 PATH。我使用符号链接替换了 android-sdk 中的 adb 版本，但只需“sudo apt-get remove android-tools-adb”也可以。

Answer 49

就我而言，我发送的是空标签，即

Log.d("","My Log");

而是发送标签名称

Log.d("Class name","My Log");

希望它可以帮助某人

Answer 50

要运行Logcat，请重启Logcat，然后打开DDMS（要打开它，请单击 Android DDMS 右上角的 Android 图标。）并设置Log Level= Debug。并运行您的应用程序。

Answer 51

所有这些都没有帮助，我的 logcat 无法正常工作。

经过大量愤怒的搜索后，我找到了一个似乎可行的解决方案：
1. 确保 logcat 本身正在工作（使用工具-> Android 中的 DDMS），如果它确实再次关闭 DDMS 窗口
2. 现在转到选项卡 5（调试） ，在那里选择 Logcat（这与 Window 6 中的 logcat 不同！）
3. 窗口和 Window 6 一样是空的，但现在开始调试运行。
对我来说，调试窗口中的 logcat 现在开始再次显示所有内容！
此外，当正常运行应用程序时，Debug->logcat 视图仍然有效，而工具窗口#6“logcat”像以前一样不起作用

这是一个 hack，但是它会导致正常的 logcat 行为，其中突出显示的行和语法是调试和开发所需的。只是从现在开始，您需要通过调试窗口访问它。

Answer 52

我找到了 3 种方法来解决这个问题。

1. 在 Android 4.0 设备上调试（我之前在 android Lollipop 设备上运行过）。
2. 单击 DDMS 中的重新启动按钮。
3. 启动 Android Device Monitor ，您将在 logcat 中找到日志。祝你好运~

Answer 53

检查您是否隐藏了它...如果它隐藏了问题，请通过给定的图像显示它或 ALT + 6

Answer 54

在我的情况下，它通过 TCP 连接断开连接，即使设备出现了。

打电话

adb connect <device ip>

重新启动 logcat 确定。

Answer 55

我的手机上有一个自定义 ROM，由于某种原因没有输出 logcat，但是模拟器和另一个设备可以。擦除并安装 ROM 使 logcat 再次工作。

Answer 56

您可以在搜索中添加一些文本并过滤掉 Logcat 结果。
这就是我的问题的原因:)

Answer 57

就我而言，我试图用其他答案来解决这个问题，但没有结果。我无意中发现空标签几乎从不显示（Android Studio 1.4）。因此，请尝试在 TAG 中输入任何字母（空格无效）。

Log.wtf("x", "Android Studio Team, solve this, please!");

Answer 58

好吧，我已经尝试了所有其他答案，但对于可怜的 logcat 没有任何效果。我对 logcat 的问题是它从一开始就没有用。从我安装 Android Studio 并最终能够将设备连接到 adb 开始，它从未给我输出。这可能是由于我的 32 位 Windows 7 设置太糟糕了……所以我编写了一个批处理脚本来通过终端运行使用 logcat 运行应用程序。

adb shell am start -n "com.package.name/com.package.name.Activity" -a android.intent.action.MAIN -c android.intent.category.LAUNCHER
adb shell pidof com.package.name > pid
for /f %%i in (pid) do (set pid=%%i)
echo %pid%
adb logcat *:V --pid=%pid%
ENDLOCAL

将其与更正的目录路径和包名称一起放入 logcat.bat（或任何.bat）文件中。

将文件放在您的 AndroidStudioProjects/package_name/ 文件夹中，然后您可以运行

C:\User\me\AndroidStudioProjects\package_name>logcat（或其他）

在终端。

请注意，您可以通过更改来更改 logcat 显示的内容

*:V

在 adb logcat 命令中。（示例 *:E 仅显示 (E)rror 标签）。

我希望这对其他人有帮助。

Answer 59

禁用并卸载您最近安装但未使用的任何插件。

Answer 60

重新启动您的 logcat 。它将修复

Answer 61

检查日志标签中的空间。如果您的标签由空格组成，则删除空格然后运行。您将能够查看日志。

Answer 62

BuildConfig除了所有很棒的答案：如果您使用它，请确保您正确导入。我正在使用BuildConfig.DEBUG，所以有一天我的 IDE 自动导入了错误的类

import com.google.firebase.BuildConfig;

或者它可能是

import com.adjust.sdk.BuildConfig;

将导入更改为正确的后，一切都很好：

import com.yourapp.BuildConfig;

Answer 63

对于 Windows 用户：

使用此脚本工具。确保您已经为系统设置了 ADB 环境。 Android Logcat 脚本

1. 保存到bat文件
2. 编辑文件。替换com.example.abc为您的包裹 ID
3. 双击打开文件或通过 MobaXTerm 打开（方便查找文本）

p / s：如果这个答案有帮助，让我们给我的回购加注星标。谢谢！