Waarom werkt “System.out.println” niet in Android?

Ik wil iets in de console afdrukken, zodat ik het kan debuggen. Maar om de een of andere reden wordt er niets afgedrukt in mijn Android-applicatie.

Hoe debug ik dan?

public class HelloWebview extends Activity {
    WebView webview;    
    private static final String LOG_TAG = "WebViewDemo";
    private class HelloWebViewClient extends WebViewClient {
        @Override
        public boolean shouldOverrideUrlLoading(WebView view, String url) {
            view.loadUrl(url);
            return true;
        }
    }
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        webview = (WebView) findViewById(R.id.webview);
        webview.setWebViewClient(new HelloWebViewClient());
        webview.getSettings().setJavaScriptEnabled(true);
        webview.setWebChromeClient(new MyWebChromeClient());
        webview.loadUrl("https://example.com/");    
        System.out.println("I am here");
    }

Antwoord 1, autoriteit 100%

Correctie:

Op de emulator en de meeste apparaten wordt System.out.printlndoorgestuurd naar LogCat en afgedrukt met Log.i(). Dit is mogelijk niet het geval bij zeer oude of aangepaste Android-versies.

Origineel:

Er is geen console om de berichten naar te sturen, dus de System.out.printlnberichten gaan verloren. Op dezelfde manier gebeurt dit wanneer u een “traditionele” Java-toepassing uitvoert met javaw.

In plaats daarvan kunt u de klasse Android Loggebruiken :

Log.d("MyApp","I am here");

U kunt het log vervolgens bekijken in de Logcat-weergave in Eclipse, of door de volgende opdracht uit te voeren:

adb logcat

Het is goed om er een gewoonte van te maken om naar logcat-uitvoer te kijken, omdat daar ook de Stack Traces van niet-afgevangen Exceptions worden weergegeven.

De eerste toegang tot elke log-oproep is de log-tag die de bron van het logbericht identificeert. Dit is handig omdat u de uitvoer van het logboek kunt filteren om alleen uw berichten weer te geven. Om er zeker van te zijn dat u consistent bent met uw log-tag, is het waarschijnlijk het beste om deze eenmaal ergens als een static final Stringte definiëren.

Log.d(MyActivity.LOG_TAG,"Application started");

Er zijn vijf éénletterige methoden in Logdie overeenkomen met de volgende niveaus:

• e()– Fout
• w()– Waarschuwing
• i()– Informatie
• d()– Foutopsporing
• v()– Uitgebreid
• wtf()– Wat een verschrikkelijke mislukking

De documentatie zegt het volgende over de niveaus:

Uitgebreide mag nooit in een toepassing worden gecompileerd, behalve tijdens de ontwikkeling. Foutopsporingslogboeken worden gecompileerd maar tijdens runtime verwijderd. Fout-, waarschuwings- en infologboeken worden altijd bijgehouden.

Antwoord 2, autoriteit 8%

Gebruik de Logklasse. Uitvoer zichtbaar met LogCat

Antwoord 3, autoriteit 7%

Ja, dat doet het. Als u de emulator gebruikt, wordt deze weergegeven in de Logcat-weergave onder de tag System.out. Schrijf iets en probeer het in je emulator.

Antwoord 4

Natuurlijk, om het resultaat in logcat te zien, moet je het Log-niveau op zijn minst instellen op “Info” (Logniveau in logcat); anders zie je, zoals mij is overkomen, je output niet.

Antwoord 5

als je System.out.println echt nodig hebt om te werken (het wordt bijvoorbeeld aangeroepen vanuit een bibliotheek van derden). je kunt eenvoudig reflectie gebruiken om het veld in System.class te wijzigen:

try{
    Field outField = System.class.getDeclaredField("out");
    Field modifiersField = Field.class.getDeclaredField("accessFlags");
    modifiersField.setAccessible(true);
    modifiersField.set(outField, outField.getModifiers() & ~Modifier.FINAL);
    outField.setAccessible(true);
    outField.set(null, new PrintStream(new RedirectLogOutputStream()); 
}catch(NoSuchFieldException e){
    e.printStackTrace(); 
}catch(IllegalAccessException e){
    e.printStackTrace(); 
}

RedirectLogOutputStream-klasse:

public class RedirectLogOutputStream extends OutputStream{
    private String mCache;
    @Override
    public void write(int b) throws IOException{
        if(mCache == null) mCache = "";
        if(((char) b) == '\n'){
            Log.i("redirect from system.out", mCache);
            mCache = "";
        }else{
            mCache += (char) b;
        }
    }
}

Antwoord 6

het wordt niet weergegeven in je applicatie… het staat onder de logcat van je emulator

Antwoord 7

Er is geen plaats op uw telefoon waar u de System.out.println();

kunt lezen

Als je het resultaat van iets wilt zien, kijk dan in je logcat/console-venster of maak een Toastof een Snackbar(als je een nieuwer apparaat gebruikt) verschijnen op het scherm van het apparaat met het bericht 🙂
Dat is wat ik doe als ik bijvoorbeeld moet controleren waar het naartoe gaat in een switch casecode! Veel plezier met coderen! 🙂

Antwoord 8

System.out.println(“…”) wordt weergegeven op de Android Monitor in Android Studio

Antwoord 9

Ik laat dit voor verdere bezoekers, want voor mij was het iets over het feit dat de hoofdthread niet in staat was System.out.printlnte gebruiken.

public class LogUtil {
private static String log = "";
private static boolean started = false;
public static void print(String s) {
    //Start the thread unless it's already running
    if(!started) {
        start();
    }
    //Append a String to the log
    log += s;
}
public static void println(String s) {
    //Start the thread unless it's already running
    if(!started) {
        start();
    }
    //Append a String to the log with a newline.
    //NOTE: Change to print(s + "\n") if you don't want it to trim the last newline.
    log += (s.endsWith("\n") )? s : (s + "\n");
}
private static void start() {
    //Creates a new Thread responsible for showing the logs.
    Thread thread = new Thread(new Runnable() {
        @Override
        public void run() {
            while(true) {
                //Execute 100 times per second to save CPU cycles.
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //If the log variable has any contents...
                if(!log.isEmpty()) {
                    //...print it and clear the log variable for new data.
                    System.out.print(log);
                    log = "";
                }
            }
        }
    });
    thread.start();
    started = true;
}
}

Gebruik: LogUtil.println("This is a string");

Antwoord 10

Ik heb geen mooie IDE om LogCat te gebruiken omdat ik een mobiele IDE gebruik.

Ik moest verschillende andere methoden gebruiken en ik heb de klassen en hulpprogramma’s die je kunt gebruiken als je dat nodig hebt.

1. klasse jav.android.Msg. Heeft een verzameling statische methoden.
   A: methoden voor het afdrukken van Android TOASTS.
   B: methoden om een dialoogvenster te openen.
   Elke methode vereist een geldige context. U kunt de standaardcontext instellen.

2. Een ambitieuzere manier, een Android-console. U maakt een handvat naar de console in uw app, die de console start (als deze is geïnstalleerd), en u kunt naar de console schrijven. Ik heb onlangs de console bijgewerkt om leesinvoer van de console te implementeren. Die niet terugkeert totdat de invoer is ontvangen, zoals een gewone console.
   A: Download en installeer Android Console (krijg het van mij)
   B: Er wordt een java-bestand meegeleverd (jav.android.console.IConsole). Plaats het in de juiste map. Het bevat de methoden om Android Console te bedienen.
   C: Roep de constructor aan die de initialisatie voltooit.
   D: lees<*> en schrijf de console.
   Er is nog werk aan de winkel. Omdat OnServiceConnected namelijk niet onmiddellijk wordt aangeroepen, kunt u IConsole niet gebruiken in dezelfde functie als waarmee u het heeft geïnstantieerd.

3. Voordat ik Android Console maakte, heb ik Console Dialog gemaakt, een dialoogvenster dat in dezelfde app werkte en op een console leek. Pro: u hoeft niet op OnServiceConnected te wachten om het te gebruiken. Nadeel: wanneer de app crasht, krijg je niet het bericht dat de app is gecrasht.

Aangezien Android Console een aparte app is in een apart proces, krijg je zeker de fout te zien als je app crasht. Verder stelt IConsole een niet-afgevangen uitzonderingshandler in uw app in voor het geval u niet geïnteresseerd bent in het afhandelen van uitzonderingen. Het drukt vrijwel de stacktraces en uitzonderingsberichten af naar Android Console. Ten slotte, als Android Console crasht, stuurt het zijn stacktrace en uitzonderingen naar u en kunt u een app kiezen om het te lezen. Eigenlijk hoeft AndroidConsole niet te crashen.

Extra’s bewerken
Ik merkte dat mijn while APK Builder geen LogCat heeft; AIDE doet dat wel. Toen realiseerde ik me een pro van het gebruik van mijn Android-console hoe dan ook.

1. Android Console is ontworpen om slechts een deel van het scherm in beslag te nemen, zodat u zowel uw app als de gegevens die door uw app naar de console worden verzonden, kunt zien. Dit is niet mogelijk met AIDE. Dus ik wil het scherm aanraken en coördinaten zien, Android Console maakt dit gemakkelijk.

2. Android Console is ontworpen om te verschijnen wanneer je ernaar schrijft.

3. Android-console wordt verborgen als je terugdrukt.

Antwoord 11

Onlangs merkte ik hetzelfde probleem op in Android Studio 3.3. Ik sloot de andere Android-studioprojecten en Logcat begon te werken. Het geaccepteerde antwoord hierboven is helemaal niet logisch.