我昨天安装了 Android Studio，并尝试使用 LogCat 查看日志。但是在 logcat 中没有什么可显示的。我使用终端运行./adb logcat，它可以工作。
有谁能给我解释一下如何在 Android Studio 中使用 logcat 吗？
【问题讨论】：
标签： android-studio logcat
重新启动 logcat 总是对我有帮助。
【讨论】：
我经常进入这种状态。 Logcat 为空白。调试工作，我可以打断点。没有设置过滤器。日志级别为详细。我通过反复循环以下内容来修复它：
adb kill-server && adb start-server
ddms。如果一切都失败了，最后重新启动计算机。
问题是间歇性的，我认为 Android Studio 只是有问题。
【讨论】：
您需要按两次 Alt+6 来重新启动 logcat 窗口。这样它就会显示日志输出。
问题主要发生在调试模式。
【讨论】：
修复一些不必要的更改的最佳方法是使缓存无效
转到 FILE -> 点击“INVALIDATE CACHES/RESTART”然后会弹出一个对话框， 选择“无效缓存/重新启动”按钮。
Android studio 会自动重启并重建索引。
【讨论】：
这些对我有帮助：
1.启用 ADB 集成 2. 进入安卓设备监视器 检查您的设备是否在线并创建所需的过滤器
【讨论】：
在终端中运行此命令。它将再次开始工作。
adb kill-server && adb start-server
【讨论】：
在 android Studio 应用程序中，您需要单击调试应用程序选项 (Shift+f9) 以在调试模式下运行并启用 LogCat。
【讨论】：
重新启动 Android Studio 对我有帮助。
【讨论】：
不是技术性答案，但您可能需要检查 logcat 的搜索框。如果输入了任何字符，您的 logcat 将为空，因为它将搜索该特定字符或单词，然后如果它不存在，您的 logcat 日志将完全为空。
【讨论】：
**
**
经过几个月的烦恼和麻烦，我刚刚解决了这个问题。
没有任何帮助，设备监视器在调试期间工作正常，但标准 logcat 视图始终为空。
原因很简单：
logcat 视图在那里，但它已通过更新移动到 0 宽度！
您在“ALT 6”选项卡中，您会在其中看到两个选项卡“ADB 日志”和“设备 | logcat”
设备 | logcat 实际上意味着它由 Devices 和 logcat 组成，由垂直边框分隔。
垂直边框可以移动，并且在更新期间它似乎已向右移动到 100%。
这会导致 logcat 被收集但不显示，将鼠标指针移动到工具窗口的右侧，然后将 logcat 拖回视图。
这个解决方案不能帮助所有人，但我发现很多人都在使用 ADB 连接，但仍然没有 logcat 输出，这些人可能会遇到同样的问题。
【讨论】：
尝试关闭项目并重新打开它。它对我有用。日志将重新出现。
【讨论】：
就我而言，在开发者选项菜单中有一个名为
的选项Revoke USB debugging authorisations。
一旦您撤销所有现有授权，它会再次要求信任您正在使用的计算机，之后它会再次开始显示日志。
【讨论】：
即使在最新版本的 Android Studio 上仍然遇到此问题，这很奇怪。我通读了一长串解决方案，但它们对我不起作用。 接受的答案适用于早期版本的 Android Studio（我猜它是 v2.3）
为了让 Logcat 再次工作，我做了以下操作：
我希望重置 logcat 理想情况下应该会给我同样的效果，但事实并非如此。手动切换过滤器是唯一有效的方法。
这是在 Android Studio 3.0.1（稳定）上（在完成当前项目之前我无法更新它） 当我早上启动 Android Studio 继续我晚上离开的工作时，出现了这个问题。我希望开发人员会对此进行调查。尝试了超过 15 种来自 stackoverflow 的解决方案，但仍然看不到任何结果。为这个问题的未来受害者揭示另一种解决方案甚至令人恼火。
【讨论】：
当其他一切都不起作用时，这就是我所做的。由于adb logcat 运行良好，我决定依赖它。在 Android Studio 的嵌入式终端中运行 adb logcat -v color 会产生类似于普通 logcat 的输出，并且代码链接也可以工作：
但这带来了一些问题：
--pid=<your PID> 选项，您可以查看单个进程的输出。但由于每次重启应用时 PID 都会发生变化，因此每次重启时都会重新运行此命令。所以我决定制作自己的工具来自动监视我的包 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不允许在不编写系统特定代码的情况下从控制台输入单个字符。对不起！
我希望这能解决你的问题:)
【讨论】：
在 Android 3.6.1 中，我必须：
【讨论】：
这可能不是您的问题，但我发现当 Android Studio 的多个窗口打开时，logcat 只会被定向到其中一个，而不一定是正在运行活动应用程序的那个。
例如，窗口 1 是我开发井字游戏应用的地方，窗口 2 是我开发天气应用的地方。如果我在调试模式下运行天气应用程序，可能只有窗口 1 能够显示 logcat 条目。
【讨论】：
在“设备 logcat”选项卡的右侧，有一个按钮“仅显示所选进程中的 Logcat”。它并不完美，因为每次我运行另一个进程时，我都需要再次推送它，但这是唯一适合我的解决方案。到目前为止...
【讨论】：
对我来说，问题是设备以Charge only 模式连接。
将模式更改为Media device (MTP)（或在某些设备中为Transfer files）解决了问题。
【讨论】：
第 1 步：在 Android 开发者选项开启和 USB 调试开启的情况下连接您的手机。
第 2 步：转到View > Tools Window > Logcat
第 3 步： 在运行项目之前确保您的手机连接 Android Studio。然后运行应用程序
注意：如果无法显示 Logcat，只需重启 Android Studio 即可：File > Invalid Caches/ restart
【讨论】：
在 Android Studio 0.8.0 中，您应该在运行应用程序之前通过工具 -> Android 启用 ADB 集成。然后日志猫将正常工作。请注意，如果您在应用程序运行时禁用 ADB 集成并再次启用它，那么除非您重新构建项目，否则 log cat 不会显示任何内容。
【讨论】：
在我的例子中，我只是过滤了输出，所以即使在重新启动 Logcat 等之后它也显示为空。
【讨论】：
我的问题解决了，我在 AndroiManifest.xml 的应用程序下添加 android:debuggable="true" （甚至 ide 标记为错误的语法！？？ ??)
【讨论】：
在 Android Studio 0.8.9 中，我打开 Android Device Monitor，从 Devices 列表中选择我的模拟器并在 LogCat 中获得输出> 选项卡。
之后，我回到 Android Studio 的主视图，在 Android DDMS 选项卡的右侧选择了Restore Logcat view，就可以了！
如果这不起作用，您可以在 Android 设备监视器 中看到您的 logcat，正如我在第一句话中解释的那样。
【讨论】：
今天遇到了同样的问题。
显然我也运行了 eclipse，所有的 logcat 输出都被重定向到了 eclipse。由于日志只能一次显示，请确保您没有运行多个调试器。
【讨论】：
确保您正在导入正确的类
import android.util.Log;
【讨论】：