Zeitgesteuerte Code-Ausführung in Android

Question

Wie lässt sich die Ausführung in Android am einfachsten verzögern?

Ich habe mich ein wenig umgesehen und habe TimingLogger im Android SDK gefunden, und Anweisungen aquí . Es sieht sehr praktisch aus. Aber ich kann es nicht zum Laufen bringen. Dies ist mein Code:

TimingLogger timings = new TimingLogger("TopicLogTag", "Parsing html");
   My code to time here...
timings.dumpToLog();

Es soll die Zeiten in LogCat ablegen. Aber ich kann nichts sehen I Was mache ich falsch? Eclipse zeigt keine Warnungen an. Ich vermute, es hat etwas mit der Verbose-Ausgabe zu tun, aber ich habe LogCat so eingestellt, dass es Verbose anzeigt. Vielen Dank

Answer 1

Ich habe einen Testlauf gemacht und erlebe das Gleiche. Es läuft alles auf diesen kleinen Teil der Beschreibung in der Javadoc für TimingLogger :

Wenn die Option Log.isLoggable nicht aktiviert ist nicht mindestens auf die Stufe Log.VERBOSE für dieses Tag zum Zeitpunkt der Erstellung nicht aktiviert ist, wird die addSplit- und dumpToLog-Aufrufe nichts.

Ich habe einen Test vor Ort durchgeführt:

TimingLogger timings = new TimingLogger("MyTag", "Initialization");
Log.d("MyTag", "Is Loggable? " + Log.isLoggable("MyTag", Log.VERBOSE));
timings.dumpToLog();

Und seltsamerweise erhalte ich eine Ausgabe in das Protokoll:

06-28 08:35:18.693: DEBUG/MyTag(24366): Is Loggable? false

Aber das war's auch schon. Und da es falsch ist, bezweifle ich, dass TimingLogger irgendetwas tut, basierend auf dem TimingLogger-Code :

  90     /**
  91      * Clear and initialize a TimingLogger object that will log using
  92      * the tag and label that was specified previously, either via
  93      * the constructor or a call to reset(tag, label). If the
  94      * Log.isLoggable is not enabled to at least the Log.VERBOSE
  95      * level for that tag at creation time then the addSplit and
  96      * dumpToLog call will do nothing.
  97      */
  98     public void reset() {
  99         mDisabled = !Log.isLoggable(mTag, Log.VERBOSE);
 100         if (mDisabled) return;
 101         if (mSplits == null) {
 102             mSplits = new ArrayList<Long>();
 103             mSplitLabels = new ArrayList<String>();
 104         } else {
 105             mSplits.clear();
 106             mSplitLabels.clear();
 107         }
 108         addSplit(null);
 109     }

Ich bin nicht sicher, warum Log.isLoggable false zurückgibt, wenn es offensichtlich bei über VERBOSE protokolliert, da meine Log.d offensichtlich protokolliert.

Sie können die Protokollierung für dieses Tag manuell in der [Log class Javadoc][3] aktivieren:

Sie können die Standardstufe ändern, indem Sie eine Systemeigenschaft setzen: 'setprop log.tag. ' Wobei Level entweder VERBOSE, DEBUG, INFO, WARN, ERROR, ASSERT, oder SUPPRESS. SUPPRESS schaltet die gesamte Protokollierung für Ihr Tag. Sie können auch eine local.prop-Datei erstellen, die mit dem folgenden Eintrag enthält: 'log.tag.=' und platzieren Sie diese in /data/local.prop.

Das habe ich durch adb shell :

$ adb shell
# setprop
usage: setprop <key> <value>
# setprop log.tag.MyTag VERBOSE
# 

Ergebnisse in:

06-28 08:53:42.447: DEBUG/MyTag(24739): Is Loggable? true
06-28 08:53:44.744: DEBUG/MyTag(24739): Initialization: begin
06-28 08:53:44.744: DEBUG/MyTag(24739): Initialization: end, 0 ms

Siehe den Kommentar von droidgren zu dieser Antwort - offenbar ist auch ein Aufruf von addSplit erforderlich.

[3]: [http://developer.Android.com/reference/Android/util/Log.html#isLoggable(java.lang.String](http://developer.android.com/reference/android/util/Log.html#isLoggable(java.lang.String) , int)

Answer 2

Ich habe eine andere, einfachere Lösung gefunden, die genau dieselbe Zeit misst wie TimingLogger und die kein setprop benötigt.

private long startnow;
private long endnow;

startnow = android.os.SystemClock.uptimeMillis();
*Your time consuming code here*
endnow = android.os.SystemClock.uptimeMillis();
Log.d("MYTAG", "Execution time: " + (endnow - startnow) + " ms");

Answer 3

Wenn ihr einen Blick auf seine Quellcode ist eigentlich die Implementierung für die TimingLogger Klasse ist ganz einfach.

Was ich also tat, was perfekt für meinen Anwendungsfall passt, war meine eigene Version der Klasse zu machen, aber die Änderung der reset() Methode zu

public void reset() {
    mDisabled = false; // <- This is what has changed.
    if (mDisabled) return;
    if (mSplits == null) {
        mSplits = new ArrayList<Long>();
        mSplitLabels = new ArrayList<String>();
    } else {
        mSplits.clear();
        mSplitLabels.clear();
    }
    addSplit(null);
}

Der Haken an der Sache ist der Wechsel von

mDisabled = !Log.isLoggable(mTag, Log.VERBOSE);

zu

mDisabled = false;

Auf diese Weise müssen wir uns nicht mit adb herumschlagen.

Answer 4

Wenn Sie einfach nur nach Protokollen suchen, wie unter developer.Android.com beschrieben, werden Sie keine Protokolle sehen können. Verwenden Sie daher den folgenden Befehl:

1. adb shell setprop log.tag.MyTag VERBOSE

Hinweis : MyTag ist der erste Parameter, den Sie bei der Erstellung eines neuen TimingLogger wie unten beschrieben übergeben:

TimingLogger timings = new TimingLogger("MyTag", "MyMethodName");

Für die Beantwortung Ihrer Fragen sollten Sie den folgenden Befehl ausführen: adb shell setprop log.tag.TopicLogTag VERBOSE

Und da sind Sie. Viel Spaß beim Codieren!!!

Answer 5

Manchmal müssen wir nicht die genaue Zeit wissen, die eine Operation gedauert hat, aber wir wollen wissen, warum diese Operation so lange gedauert hat. Um den Code zu beschleunigen, müssen wir also nur eine Art relationale Reihenfolge der Teile dieser Operation kennen, wobei derjenige, der die meiste Zeit in Anspruch nimmt, derjenige zu sein scheint, den man optimieren sollte. Deshalb bietet Android die Methodenverfolgung:

Debug.startMethodTracing("YOUR_TRACE_FILE_NAME");

// Do your operations

Debug.stopMethodTracing();

Anschließend schreibt das Betriebssystem die Trace-Datei mit allen Aufrufinformationen in das Dateisystem. Ziehen Sie diese Datei einfach per Drag'n'Drop auf traceview.bat und prüfen Sie, welche Anrufe wie lange gedauert haben.

Vorteile:

• Sie können alle aufgerufenen Funktionen und Methoden einsehen, die während der Verfolgung aufgerufen wurden.
• Bei Multithreading-Anwendungen müssen keine Daten synchronisiert werden.
• Trace wird automatisch in eine Datei geschrieben - es ist keine Log-Kat-Magie oder ähnliches notwendig. Alle Daten werden zusammen gekapselt und können inspiziert werden.
• Sobald man anfängt, die Zeit zu messen und vor allem zu protokollieren, geht die Zeitmessung sowieso in die Hose.

Link: http://developer.Android.com/tools/debugging/debugging-tracing.html