Question

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

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

Answer 1

重启logcat总能帮助我。

enter image description here

Answer 2

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

重启logcat（参见Zatziky上面的回答）
将日志级别更改为Debug（或其他任何内容）并返回到Verbose。
拔出并插回设备
正在运行adb kill-server && adb start-server
关闭Android Studio并在命令行上启动ddms。
重新启动Android Studio

如果所有其他方法都失败，最后重新启动计算机。

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

Answer 3

我遇到了同样的问题，但我通过以下步骤解决了这个问题，尝试过一次。

1）在android studio。

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

3）你可以看到右下角的下拉（微调）

4）选择 - 仅显示所选应用。

Answer 4

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

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

Answer 5

这些帮助了我：

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

Answer 6

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

转到文件 - ＆gt;单击“INVALIDATE CACHES / RESTART”，弹出一个对话框，选择“INVALIDATE CACHES / RESTART”按钮。

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

Answer 7

在android Studio应用程序中，您需要单击Debug application option（Shift + f9）以在调试模式下运行并启用LogCat。

Answer 8

重启Android Studio帮助了我。

Answer 9

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

Answer 10

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

Answer 11

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

Answer 12

**

如果您仍然坚持使用logcat

**

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

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

您处于“ALT 6”标签中，您会在其中看到两个标签“ADB logs”和“Devices | logcat”
设备| logcat实际上意味着它由Devices AND logcat组成，由垂直边框分割可以移动垂直边框，在更新期间，它似乎已经向右移动了100％。

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

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

Answer 13

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

adb kill-server && adb start-server

Answer 14

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

Answer 15

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

的选项

Revoke USB debugging authorisations。

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

Answer 16

在“设备logcat”选项卡的右侧，有一个按钮“仅显示选定进程的Logcat”。它并不完美，因为每次我运行另一个进程时我都需要再次推送它，但那是唯一适合我的解决方案。到目前为止......

Answer 17

在Android 3.6.1中，我必须：

升级到最新的Android Studio版本（4.x.x）
重新启动Logcat
重新启动应用
重新启动Android Studio
重新启动Android测试设备

Answer 18

我检查了答案，但在检查logcat时才偶然发现我的错误。确保右侧的框显示“仅显示选定的应用程序”。我的网站显示的是“ Firebase”，因此它向我显示了来自Firebase的消息。

Answer 19

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

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

Answer 20

第1步：将您的手机与Android Developer选项“开启”和“ USB Debug On”开启。

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

第3步：在运行项目之前，请确保您的Phone Connect Android Studio。然后运行应用程序

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

Answer 21

在我的情况下，我刚刚过滤了输出，因此即使在重新启动Logcat等后它也显示为空。

Answer 22

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

例如，Window 1是我开发Tic-Tac-Toe应用程序的地方，Window 2是我开发天气应用程序的地方。如果我在调试模式下运行天气应用程序，那么只有Window 1才能显示logcat条目。

Answer 23

我的问题解决了，在我的 AndroiManifest.xml 中添加了 android：debuggable =“true”之后（甚至将ide标记为错误的语法！ ??）

Answer 24

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

Answer 25

我刚把它修好了。查找DDMS显示最右侧的小图标，这些图标可恢复Devices Logcat视图和ADB视图。

当DDMS首次出现“ADB Logs”和“Devices | logcat”选项卡时。 “Devices | logcat”是应该显示设备输出的那个，但是是空白的。不知怎的，我设法隐藏了这些标签中的一个或另一个，我忘了究竟是怎么回事。但是，在右边有一个小图标，上面写着“恢复ADB”视图，然后我点击了它，它就出现了。然后还有另一个小图标，上面写着“Restore Devices logcat view”。我点击了它，突然它出现了，并再次显示设备输出。

Answer 26

在Android Studio 0.8.9中，我打开了 Android设备监视器，从设备列表中选择了我的模拟器，并获得了 LogCat 标签。

之后，我回到了Android Studio的主视图，并选择了 Android DDMS 标签右侧的还原Logcat视图，就在那里！

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

Answer 27

今天有同样的问题。

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

Answer 28

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

我做了以下操作以使Logcat重新工作：

Logcat>仅显示选定的应用程序>没有过滤器

Logcat>没有过滤器>仅显示选定的应用程序

我希望重置logcat理想情况下会给我相同的效果，但实际上没有。手动切换过滤器是唯一有效的方法。

这是在Android Studio 3.0.1（稳定）上执行的（我无法在完成当前项目之前对其进行更新）问题发生在我早上启动Android Studio来继续我晚上留下的工作时。我希望开发人员可以对此进行研究。尝试从stackoverflow尝试15种以上的解决方案仍然很费劲，但仍然看不到结果。为这个问题的未来受害者透露另一种解决方案甚至令人不快。

Answer 29

对我而言，它不仅仅适用于我的应用程序，如果没有选择过滤器，它正在工作（右侧选项）。但我需要只看到我的应用程序，因此我发现，如果我自己做过滤器并将其过滤到包名称，它就可以正常工作了。我希望它对你也有帮助:)）

Answer 30

我尝试了上面的建议。但是，它们都没有奏效。然后，我做了以下令人惊讶的工作：

断开USB与设备的连接
使用命令adb tcpip 5555和adb connect <device ip>
使用adb kill-server
通过USB

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

Answer 31

首先在您的设备中启用Sure开发人员选项。
设备已连接。
详细。
仅显示所选应用程序。

Answer 32

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

Answer 33

Logcat在logcat右侧有一个小图标。您可以使用该图标打开和关闭logcat。我通常可以通过单击图标激活logcat（可能是几次）。

Answer 34

确保在模拟器开发者菜单选项中具有Logger缓冲区大小适当的值。

Answer 35

当其他所有方法均无效时，这就是我所做的。由于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 36

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

Answer 37

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

您可能有以下不同版本的adb：＆＃34; sudo apt-get install android-tools-adb＆＃34;这将创建/ usr / bin / adb Android SDK包含{android-sdk} / platform-tools / adb，或者从AOSP构建的输出中创建出/ host / linux-x86 / bin / adb

要查看此问题是否会影响您，请使用＆＃34;帮助 - ＆gt;打开idea.log;显示登录文件＆＃34;并寻找像＆＃34;初始化adb的行：/ home / repkap11 / android-sdk / platform-tools / adb＆＃34;。将此路径与＆＃34; adb＆＃34;在你的终端。如果他们不匹配，这个问题就会影响你。

Android工作室会查找{android-sdk} / platform-tools / adb，并不关心你的PATH。我使用符号链接替换了android-sdk中的adb版本，但只是＆＃34; sudo apt-get remove android-tools-adb＆＃34;也可以。

Answer 38

确保输入正确的课程

import android.util.Log;

Answer 39

尝试点击＆＃34; Android＆＃34;右侧部分的图标在视图中，您应该在Android视图上看到Logcat选项卡（您可以通过按Alt + 6来启动Android视图）

Answer 40

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

Answer 41

全核解决方案。在尝试所有操作之后，只能使用它，因为这将删除所有设置和首选项以及存储的图像以及使模拟器运行的所有内容，直到重新安装和重新配置为止。在我的情况下，两个步骤花了大约20分钟，因为除了使用Darcula之外我没有定制很多。

删除.AndroidStudioBeta配置文件目录

对于linux用户，可以在/home/[username]/.AndroidStudioBeta下找到对于Windows用户，我不确定。在我看来，关于它的文件相当含糊。可能在C：\ Users [您的用户] \ Application Data

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

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

Answer 42

转到run-＆gt; debug 如果您丢失了与主机的连接，它将要求重新连接的权限。单击是。应该这样做。

Answer 43

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

解决方案只是为了验证我有正确的过滤器集。

Answer 44

在这个帖子中尝试@Robert Karl提到的观点。如果没有任何作用，那么你肯定可以通过Android设备监视器看到日志。

启动Android设备监视器
选择DDMS透视图，
然后选择您的设备，如屏幕截图所示。

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

enter image description here

Answer 45

重新启动我正在测试的电话即可解决此问题。

我在Android 6上使用了旧版LG4。

我尝试再次拔插，重新启动Android Studio，重新启动logcat，使缓存无效-没用。

Answer 46

也要小心这个坏小子（即使重启android studio也没有消失）：

Answer 47

您可以在搜索中添加一些文字，并过滤出Logcat结果。
那就是我的问题的原因：）

Answer 48

除了所有出色的答案外：请确保您正确使用BuildConfig导入。我使用的是BuildConfig.DEBUG，所以有一天我的IDE自动导入了错误的类

import com.google.firebase.BuildConfig;

或者可能是

import com.adjust.sdk.BuildConfig;

将导入更改为右侧后，一切都很好：

import com.yourapp.BuildConfig;

Answer 49

重新启动logcat。它会解决

Answer 50

对于Windows用户：

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

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

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

Answer 51

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

Answer 52

就我而言，我正在发送空标签，即

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

发送标签名称

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

希望它对某人有帮助

Answer 53

好吧，我已经尝试了所有其他答案，但对于可怜的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（或what.bat）文件中。

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

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

在终端中。

请注意，您可以通过更改

来更改logcat的显示内容

*：V

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

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

Answer 54

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

Answer 55

所有这些都没有帮助，我的logcat失去了功能。

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

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

Answer 56

我手机上有一个自定义ROM，由于某种原因没有输出logcat，但是模拟器和其他设备都没有。擦除和安装ROM使logcat再次运行。

Answer 57

检查你是否隐藏了它...如果它隐藏了问题，请通过给定图像显示它或ALT + 6 enter image description here

Answer 58

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

我在我的i9505上运行Kushan的Galaxy S4 Rom并且我不知道它默认禁用了日志记录以获得最高级别的性能提升，但显然这在定制的“性能”上并不少见“面向罗姆斯......让我有一个发现这个的时代 - 非常烦人，因为它会告诉我记录了多少消息，而不是他们的细节。

Answer 59

在我的情况下，我尝试用其他答案解决这个问题，没有结果。我无意间发现，几乎从未显示过空标签（Android Studio 1.4）。因此，尝试在标签内放置任何字母（空格不起作用）。

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

Answer 60

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

调用

adb connect <device ip>

重新启动logcat确定。

Answer 61

我找到了3种解决方法。

在Android 4.0设备上进行调试（我之前在Android Lollipop设备上运行它。）
点击DDMS中的重启按钮。
启动Android设备监视器，您将找到登录logcat。祝你好运〜

Answer 62

要运行 Logcat ，请重新启动 Logcat ，然后打开 DDMS （要打开它，请点击右上角的Android图标Android DDMS。）并设置日志级别=调试。并运行您的应用程序。

Answer 63

你可以做以下事情。 1.重启logcat 2.如上所述，从verberos更改为调试，然后返回verberos 3.最后一次更改正则表达式仅显示所选选项。它现在肯定会奏效。

Android studio logcat无需显示

63 个答案:

免责声明