Android工作室logcat没有显示

确保您导入了正确的类

import android.util.Log;

试试@Robert Karl在这篇文章中提到的观点。如果没有工作，那么你肯定可以通过android设备监视器看到日志。

1. 打开android设备监视器

2. select DDMS perspective，

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

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

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

Android studio将自动重新启动并重新构建索引。

执行->debug命令 如果你失去了与主机的连接，它会要求重新连接。单击yes。

这些帮助了我:

我有同样的症状，但我的问题要简单得多，这真的是我的错误。我的滤镜设置错了。

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

要运行Logcat，重新启动Logcat，然后打开摘要讨论(要打开它，单击Android DDMS右上角的Android图标)。并设置日志级别=调试。然后运行你的应用。

我刚把它修好了。在DDMS显示的最右边寻找恢复Devices Logcat视图和ADB视图的小图标。

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

我找到了三种解法。

1. 在Android 4.0设备上调试(我之前在Android Lollipop设备上运行它)。
2. 单击DDMS中的重启按钮。
3. 启动Android设备监视器，你会发现logcat。祝你好运~

在我的例子中，它通过TCP连接断开，即使设备出现了。

调用

adb connect <device ip>

重启logcat OK。

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

尝试点击“Android”视图最右边的图标，你应该在Android视图上看到Logcat选项卡(你可以通过按Alt+6打开Android视图)

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

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

要查看这个问题是否影响到你，使用“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”也可以。

试着关闭项目，然后重新打开它。这对我很有用。日志将重新出现。

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

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

一些自定义rom禁用日志记录出于性能原因(压缩%的任何地方)检查你的rom的内置应用程序或调整你的rom的菜单来启用这一点。

我在我的i9505上运行贵山的Galaxy S4 Rom，我不知道它默认禁用了日志记录，以获得最分钟的性能提升，但显然这在定制的“性能”导向型Rom上并不罕见。我花了一段时间才发现这一点-非常烦人，因为它会显示我有多少消息被记录，而不是他们的细节。

对我来说，问题是我有两个名称相同的模拟器(我创建了它，删除了它，然后用相同的名称再次创建它)。在logcat下拉菜单中有两个模拟器条目，它连接到错误的一个。我所要做的就是换到另一个。我通过重命名模拟器永久地避免了这个问题。

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

我有同样的问题，但我解决了以下步骤，试一次。

1)在android工作室。

2)打开android Monitor窗口(android studio底部)

3)你可以看到右下角的下拉(旋转器)

4) select——只显示所选应用。

重新启动Android Studio帮助了我。

在我的例子中，在开发人员选项菜单中有一个名为

Revoke USB debugging authorisations。

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

在我的例子中，我从右边的小下拉列表中删除了“image”。在那之后一切都很好。这是因为它将在日志中搜索搜索框中的关键字，因此如果没有找到任何匹配项，它将返回空白

1. 首先确保在您的设备中启用了开发人员选项。
2. 设备已连接。
3. 详细的。
4. 只显示选中的应用程序。

我尝试了上面的建议。然而，没有一个成功。然后我做了下面的事情，结果出乎意料地奏效了:

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

然后LogCat显示日志。尽管在第2步时日志可用，但以下步骤在通过USB连接时为我解决了这个问题。

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

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

确保在模拟器开发人员菜单选项中有记录器缓冲区大小适当值。

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

1. Logcat >只显示选中的应用>不显示过滤器

2. Logcat >不过滤>只显示选中的应用

我期望重置logcat应该理想地给我同样的效果，但它没有。手动切换滤镜是唯一有效的方法。

这是在Android Studio 3.0.1(稳定)(我不能在完成当前项目之前更新它) 问题发生在我早上启动Android工作室继续我晚上留下的工作时。我希望开发人员能研究一下这个问题。从stackoverflow中尝试了超过15个解决方案，仍然没有看到任何结果。为这个问题的未来受害者揭示另一种解决方案甚至是令人恼火的

在终端中执行此命令。它将重新开始工作。

adb kill-server && adb start-server

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(或其他任何文件)文件中。

将文件放在AndroidStudioProjects/package_name/文件夹中，然后你就可以运行了

用户C: \ \我\ AndroidStudioProjects \ package_name > logcat(或其他)

在终点站。

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

*: V

在adb logcat命令中。(示例*:E只显示(E)错误标记)。

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

在我的情况下，我发送空标签，即

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

而是发送一个标记名称

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

希望它能帮助到别人

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

我用的是旧的LG4和Android 6。

我试着拔了又插，重新启动Android Studio，重新启动logcat，使缓存无效-什么都没有工作。

用Android开发人员选项和USB调试连接你的手机。

步骤2:到View > Tools Window > Logcat

步骤3:在运行项目之前，确保你的手机连接Android Studio。然后运行应用

如果不能显示Logcat，请重新启动Android Studio: File > Invalid Caches/ restart

在Android 3.6.1中，我必须:

• 升级到最新的Android Studio版本(4.x.x)
• 重启Logcat
• 重启应用程序
• 重启Android Studio
• 重新启动Android测试设备

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

import com.google.firebase.BuildConfig;

也可能是

import com.adjust.sdk.BuildConfig;

将import更改为正确的导入后，一切正常:

import com.yourapp.BuildConfig;

当其他方法都不管用的时候，我是这么做的。由于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也可以。

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

免责声明

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

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

重新启动logcat。它是固定的

Windows用户:

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

1. 保存到bat文件
2. 编辑文件。用你的包id替换com.example.abc
3. 双击打开文件或通过MobaXTerm打开(方便查找文本)

p/s:如果这个答案有帮助，让我们把我的回购星。谢谢!

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

还要小心这个坏男孩(即使重新启动android studio也没有消失):

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

如果你使用Android模拟器，你可以擦除数据，然后再次启动模拟器。只有这个工作为我

为我禁用通过USB验证应用程序和验证字节码 可调试的应用程序帮助我使logcat更加可靠

确保您选择了正确的模拟器，并且模拟器选择器旁边的字段不为空(在Logcat控制台中)。

检查LogCat Sitteng 在我的情况下，我不检查每一件事，使issu从我

我再次检查一切为我工作