Messen Sie Ladezeit und Bildschirmwiedergabe mit Firebase Performance Monitoring

Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

1. Einleitung

Zuletzt aktualisiert: 2021-03-11

Warum müssen wir die Leistung von Views messen?

Ansichten sind ein wichtiger Bestandteil von Android-Anwendungen, die sich direkt auf die Benutzererfahrung auswirken. Beispielsweise enthält Ihre Aktivität oder Ihr Fragment die Benutzeroberfläche, die die Ansichtskomponenten enthält, mit denen Benutzer interagieren. Benutzer können den gesamten Inhalt der Benutzeroberfläche erst sehen, wenn sie vollständig auf dem Bildschirm gezeichnet ist. Langsame und eingefrorene Bildschirme beeinträchtigen die Benutzerinteraktion mit Ihrer App direkt und führen zu einer schlechten Benutzererfahrung.

Stellt Firebase Performance Monitoring diese Leistungsmetriken nicht sofort bereit?

Firebase Performance Monitoring erfasst automatisch einige Leistungsdaten, z. B. die Startzeit Ihrer App (d. h. die Ladezeit nur für Ihre erste Aktivität) und die Bildschirmdarstellungsleistung (d. h. langsame und eingefrorene Frames für Aktivitäten, aber nicht für Fragmente). Branchen-Apps haben jedoch normalerweise nicht viele Aktivitäten, sondern eine Aktivität und mehrere Fragmente. Außerdem implementieren viele Apps normalerweise ihre eigenen benutzerdefinierten Ansichten für komplexere Anwendungsfälle. Daher ist es oft hilfreich zu verstehen, wie die Ladezeit und die Bildschirmdarstellungsleistung sowohl von Aktivitäten als auch von Fragmenten gemessen werden, indem benutzerdefinierte Codeablaufverfolgungen in Ihrer App instrumentiert werden. Sie können dieses Codelab problemlos erweitern, um die Leistung von Komponenten der benutzerdefinierten Ansicht zu messen.

Was Sie lernen werden

  • So fügen Sie Firebase Performance Monitoring zu einer Android-App hinzu
  • Verstehen des Ladens einer Aktivität oder eines Fragments
  • So instrumentieren Sie benutzerdefinierte Codeablaufverfolgungen, um die Ladezeit einer Aktivität oder eines Fragments zu messen
  • Grundlegendes zum Bildschirm-Rendering und was ein langsamer/eingefrorener Frame ist
  • So instrumentieren Sie benutzerdefinierte Code-Traces mit Metriken, um langsame/eingefrorene Bildschirme aufzuzeichnen
  • So zeigen Sie die gesammelten Messwerte in der Firebase-Konsole an

Was du brauchen wirst

  • Android Studio 4.0 oder höher
  • Ein Android-Gerät/Emulator
  • Java-Version 8 oder höher

2. Einrichten

Holen Sie sich den Code

Führen Sie die folgenden Befehle aus, um den Beispielcode für dieses Codelab zu klonen. Dadurch wird auf Ihrem Computer ein Ordner mit dem Namen codelab-measure-android-view-performance :

$ git clone https://github.com/FirebaseExtended/codelab-measure-android-view-performance.git
$ cd codelab-measure-android-view-performance

Wenn Sie Git nicht auf Ihrem Computer haben, können Sie den Code auch direkt von GitHub herunterladen.

Importieren Sie das Projekt „ measure-view-performance-start “ in Android Studio. Sie werden wahrscheinlich einige Kompilierungsfehler oder vielleicht eine Warnung über eine fehlende google-services.json Datei sehen. Wir werden dies im nächsten Abschnitt dieses Schritts korrigieren.

In diesem Codelab verwenden wir das Firebase Assistant -Plug-in, um unsere Android-App bei einem Firebase-Projekt zu registrieren und die erforderlichen Firebase-Konfigurationsdateien, Plug-ins und Abhängigkeiten zu unserem Android-Projekt hinzuzufügen – alles innerhalb von Android Studio !

Verbinden Sie Ihre App mit Firebase

  1. Gehen Sie zu Android Studio / Hilfe > Nach Updates suchen , um sicherzustellen, dass Sie die neuesten Versionen von Android Studio und dem Firebase-Assistenten verwenden.
  2. Wählen Sie Extras > Firebase aus, um den Assistentenbereich zu öffnen.

e791bed0999db1e0.png

  1. Wählen Sie Leistungsüberwachung aus, um sie Ihrer App hinzuzufügen, und klicken Sie dann auf Erste Schritte mit der Leistungsüberwachung .
  2. Klicken Sie auf Mit Firebase verbinden, um Ihr Android-Projekt mit Firebase zu verbinden (dadurch wird die Firebase-Konsole in Ihrem Browser geöffnet) .
  3. Klicken Sie in der Firebase-Konsole auf Projekt hinzufügen und geben Sie dann einen Firebase-Projektnamen ein (wenn Sie bereits ein Firebase-Projekt haben, können Sie stattdessen dieses vorhandene Projekt auswählen) . Klicken Sie auf Weiter und akzeptieren Sie die Bedingungen, um das Firebase-Projekt und eine neue Firebase-App zu erstellen.
  4. Als nächstes sollte ein Dialogfeld zum Verbinden Ihrer neuen Firebase-App mit Ihrem Android Studio-Projekt angezeigt werden.

42c498d28ead2b77.png

  1. Zurück in Android Studio sollten Sie im Assistentenbereich die Bestätigung sehen, dass Ihre App mit Firebase verbunden ist.

dda8bdd9488167a0.png

Fügen Sie Ihrer App Leistungsüberwachung hinzu

Klicken Sie im Assistentenbereich von Android Studio auf Leistungsüberwachung zu Ihrer App hinzufügen .

Sie sollten ein Dialogfeld zum Akzeptieren von Änderungen sehen, wonach Android Studio Ihre App synchronisieren sollte, um sicherzustellen, dass alle erforderlichen Abhängigkeiten hinzugefügt wurden.

9b58145acc4be030.png

Schließlich sollten Sie die Erfolgsmeldung im Assistentenbereich in Android Studio sehen, dass alle Abhängigkeiten korrekt eingerichtet sind.

aa0d46fc944e0c0b.png

Aktivieren Sie als zusätzlichen Schritt die Debug-Protokollierung , indem Sie den Anweisungen im Schritt „(Optional) Debug-Protokollierung aktivieren“ folgen. Dieselben Anweisungen sind auch in der öffentlichen Dokumentation verfügbar.

3. Führen Sie die App aus

Wenn Sie Ihre App erfolgreich in das Performance Monitoring SDK integriert haben, sollte das Projekt jetzt kompiliert werden. Klicken Sie in Android Studio auf Ausführen > „App“ ausführen, um die App zu erstellen und auf Ihrem verbundenen Android-Gerät/Emulator auszuführen.

Die App verfügt über zwei Schaltflächen, die Sie zu einer entsprechenden Aktivität und einem entsprechenden Fragment führen, wie folgt:

410d8686b4f45c33.png

In den folgenden Schritten dieses Codelabs erfahren Sie, wie Sie die Ladezeit und die Bildschirmwiedergabeleistung Ihrer Aktivität oder Ihres Fragments messen.

4. Verstehen des Ladens einer Aktivität oder eines Fragments

In diesem Schritt lernen wir, was das System während des Ladens einer Aktivität oder eines Fragments tut.

Verstehen des Ladens einer Aktivität

Für eine Aktivität ist die Ladezeit definiert als die Zeit ab dem Erstellen des Aktivitätsobjekts bis zum vollständigen Zeichnen des ersten Frames auf dem Bildschirm (zu diesem Zeitpunkt sieht Ihr Benutzer zum ersten Mal die vollständige Benutzeroberfläche für die Aktivität Zeit ). Um zu messen, ob Ihre App vollständig gezeichnet ist, können Sie die Methode reportFullyDrawn() verwenden, um die verstrichene Zeit zwischen dem Start der Anwendung und der vollständigen Anzeige aller Ressourcen zu messen und Hierarchien anzuzeigen.

Auf hoher Ebene führt das System automatisch die folgenden Prozesse aus, wenn Ihre App startActivity(Intent) aufruft. Jeder Prozess benötigt Zeit, um abgeschlossen zu werden, wodurch die Zeitspanne zwischen der Erstellung der Aktivität und dem Zeitpunkt, zu dem der Benutzer die Benutzeroberfläche für die Aktivität auf seinem Bildschirm sieht, verlängert wird.

c20d14b151549937.png

Das Laden eines Fragments verstehen

Ähnlich wie bei der Aktivität ist die Ladezeit für ein Fragment definiert als die Zeit ab dem Anhängen des Fragments an seine Host-Aktivität bis zum vollständigen Zeichnen des ersten Frames für die Fragmentansicht auf dem Bildschirm.

5. Messen Sie die Ladezeit einer Aktivität

Verzögerungen im ersten Frame können zu einer schlechten Benutzererfahrung führen, daher ist es wichtig zu verstehen, wie viel anfängliche Ladeverzögerung Ihre Benutzer erleben. Sie können einen benutzerdefinierten Code-Trace instrumentieren, um diese Ladezeit zu messen:

  1. Starten Sie die benutzerdefinierte Codeablaufverfolgung (mit dem Namen TestActivity-LoadTime ) in der Activity-Klasse, sobald das Activity-Objekt erstellt wurde.

TestActivity.java

public class TestActivity extends AppCompatActivity {   
    // TODO (1): Start trace recording as soon as the Activity object is created.
    private final Trace viewLoadTrace = FirebasePerformance.startTrace("TestActivity-LoadTime");

    // ...

}
  1. Überschreiben Sie den onCreate() -Callback und rufen Sie die View ab, die von der setContentView() Methode hinzugefügt wurde.
@Override     
public void onCreate(Bundle savedInstanceState) {    
    super.onCreate(savedInstanceState);          

    // Current Activity's main View (as defined in the layout xml file) is inflated after this            
    setContentView(R.layout.activity_test);          

    // ...

    // TODO (2): Get the View added by Activity's setContentView() method.         
    View mainView = findViewById(android.R.id.content);     

    // ...
}
  1. Wir haben eine Implementierung von FistDrawListener , die zwei Callbacks hat: onDrawingStart() und onDrawingFinish() (weitere Einzelheiten zu FirstDrawListener und was seine Leistung beeinflussen kann, finden Sie im nächsten Abschnitt unten) . Registrieren Sie den FirstDrawListener am Ende des onCreate() Rückrufs von Activity. Sie sollten Ihren viewLoadTrace im onDrawingFinish() Callback stoppen.

TestActivity.java

    // TODO (3): Register the callback to listen for first frame rendering (see
    //  "OnFirstDrawCallback" in FirstDrawListener) and stop the trace when View drawing is
    //  finished.
    FirstDrawListener.registerFirstDrawListener(mainView, new FirstDrawListener.OnFirstDrawCallback() {              
        @Override             
        public void onDrawingStart() {       
          // In practice you can also record this event separately
        }

        @Override             
        public void onDrawingFinish() {
            // This is when the Activity UI is completely drawn on the screen
            viewLoadTrace.stop();             
        }         
    });
  1. Führen Sie die App erneut aus. Filtern Sie dann den Logcat mit „ Logging Trace Metric “. Tippen Sie auf die Schaltfläche LOAD ACTIVITY und suchen Sie nach Protokollen wie unten:
I/FirebasePerformance: Logging trace metric: TestActivity-LoadTime (duration: XXXms)

🎉 Herzlichen Glückwunsch! Sie haben die Ladezeit einer Aktivität erfolgreich gemessen und diese Daten an Firebase Performance Monitoring gemeldet. Wir sehen uns die aufgezeichnete Metrik später in diesem Codelab in der Firebase-Konsole an.

Zweck von FirstDrawListener

Im obigen Abschnitt haben wir einen FirstDrawListener registriert. Der Zweck von FirstDrawListener besteht darin, zu messen, wann der erste Frame begonnen und das Zeichnen beendet hat.

Es implementiert den ViewTreeObserver.OnDrawListener und überschreibt den onDraw() Callback, der aufgerufen wird, wenn der Ansichtsbaum gezeichnet werden soll. Anschließend wird das Ergebnis umbrochen, um zwei Dienstprogramm-Callbacks onDrawingStart() und onDrawingFinish() .

Den vollständigen Code für FirstDrawListener finden Sie im Quellcode dieses Codelabs .

6. Messen Sie die Ladezeit eines Fragments

Die Messung der Ladezeit eines Fragments ähnelt der Messung für eine Aktivität, jedoch mit einigen geringfügigen Unterschieden. Auch hier instrumentieren wir einen benutzerdefinierten Code-Trace :

  1. Überschreiben Sie den onAttach() Callback und beginnen Sie mit der Aufzeichnung Ihres fragmentLoadTrace . Wir nennen diese Ablaufverfolgung Test-Fragment-LoadTime .

Wie in einem früheren Schritt erläutert, kann das Fragment-Objekt jederzeit erstellt werden, es wird jedoch nur aktiv, wenn es an seine Host-Aktivität angehängt wird.

TestFragment.java

public class TestFragment extends Fragment {

   // TODO (1): Declare the Trace variable.
   private Trace fragmentLoadTrace;

   @Override
   public void onAttach(@NonNull Context context) {
       super.onAttach(context);

       // TODO (2): Start trace recording as soon as the Fragment is attached to its host Activity.
       fragmentLoadTrace = FirebasePerformance.startTrace("TestFragment-LoadTime");
   }
  1. Registrieren Sie den FirstDrawListener im onViewCreated() Callback. Stoppen Sie dann, ähnlich wie im Aktivitätsbeispiel, die Ablaufverfolgung in onDrawingFinish() .

TestFragment.java

@Override
public void onViewCreated(@NonNull View mainView, Bundle savedInstanceState) {
   super.onViewCreated(mainView, savedInstanceState);

   // ...

   // TODO (3): Register the callback to listen for first frame rendering (see
   //  "OnFirstDrawCallback" in FirstDrawListener) and stop the trace when view drawing is
   //  finished.
   FirstDrawListener.registerFirstDrawListener(mainView, new FirstDrawListener.OnFirstDrawCallback() {

       @Override
       public void onDrawingStart() {
           // In practice you can also record this event separately
       }

       @Override
       public void onDrawingFinish() {
           // This is when the Fragment UI is completely drawn on the screen
           fragmentLoadTrace.stop();
       }
   });
  1. Führen Sie die App erneut aus. Filtern Sie dann den Logcat mit „ Logging Trace Metric “. Tippen Sie auf die Schaltfläche LOAD FRAGMENT und suchen Sie nach Protokollen wie unten:
I/FirebasePerformance: Logging trace metric: TestFragment-LoadTime (duration: XXXms)

🎉 Herzlichen Glückwunsch! Sie haben die Ladezeit eines Fragments erfolgreich gemessen und diese Daten an Firebase Performance Monitoring gemeldet. Wir sehen uns die aufgezeichnete Metrik später in diesem Codelab in der Firebase-Konsole an.

7. Verständnis der Bildschirmwiedergabe und was ein langsamer/eingefrorener Frame ist

Beim UI-Rendering wird ein Frame aus Ihrer App generiert und auf dem Bildschirm angezeigt. Um sicherzustellen, dass die Interaktion eines Benutzers mit Ihrer App reibungslos verläuft, sollte Ihre App Frames in weniger als 16 ms rendern, um 60 Frames pro Sekunde ( warum 60 fps? ) zu erreichen. Wenn Ihre App unter einem langsamen UI-Rendering leidet, ist das System gezwungen, Frames zu überspringen, und der Benutzer wird ein Stottern in Ihrer App wahrnehmen. Wir nennen das Jank .

Ebenso sind eingefrorene Frames UI-Frames, deren Rendern länger als 700 ms dauert. Diese Verzögerung ist ein Problem, da Ihre App hängen zu bleiben scheint und fast eine ganze Sekunde lang nicht auf Benutzereingaben reagiert, während der Frame gerendert wird.

8. Messen Sie die langsamen/eingefrorenen Frames eines Fragments

Die Firebase-Leistungsüberwachung erfasst automatisch langsame/eingefrorene Frames für eine Aktivität ( jedoch nur, wenn sie hardwarebeschleunigt ist ). Diese Funktion ist derzeit jedoch nicht für Fragmente verfügbar. Die langsamen/eingefrorenen Frames eines Fragments sind als die langsamen/eingefrorenen Frames für die gesamte Aktivität zwischen den onFragmentAttached() und onFragmentDetached() im Lebenszyklus des Fragments definiert.

In Anlehnung an die AppStateMonitor -Klasse ( die Teil des Leistungsüberwachungs-SDK ist, das für die Aufzeichnung von Bildschirmablaufverfolgungen für Activity verantwortlich ist ) haben wir die ScreenTrace -Klasse implementiert ( die Teil dieses Codelab-Quellcode-Repos ist ). ScreenTrace -Klasse kann mit dem Lebenszyklus-Callback des FragmentManager der Aktivität verbunden werden, um langsame/eingefrorene Frames zu erfassen. Diese Klasse stellt zwei öffentliche APIs bereit:

  • recordScreenTrace() : Startet die Aufzeichnung einer Bildschirmspur
  • sendScreenTrace() : Stoppt die Aufzeichnung einer Bildschirmspur und hängt benutzerdefinierte Metriken an, um die Anzahl der Gesamt-, langsamen und eingefrorenen Frames zu protokollieren

Durch das Anhängen dieser benutzerdefinierten Metriken können Bildschirmspuren für Fragmente genauso gehandhabt werden wie Bildschirmspuren für eine Aktivität und zusammen mit anderen Bildschirmwiedergabespuren im Leistungs -Dashboard der Firebase-Konsole angezeigt werden.

So protokollieren Sie Bildschirmspuren für Ihr Fragment:

  1. Initialisieren Sie die ScreenTrace -Klasse in Ihrer Aktivität, die das Fragment hostet.

MainActivity.java

// Declare the Fragment tag
private static final String FRAGMENT_TAG = TestFragment.class.getSimpleName();

// TODO (1): Declare the ScreenTrace variable.
private ScreenTrace screenTrace;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    // TODO (2): Initialize the ScreenTrace variable.
    screenTrace = new ScreenTrace(this, FRAGMENT_TAG);

    // ...
}
  1. Wenn Sie Ihr Fragment laden, registrieren Sie sich für FragmentLifecycleCallbacks und überschreiben Sie die onFragmentAttached() und onFragmentDetached() Callbacks. Wir haben dies für Sie erledigt. Sie müssen die Aufzeichnung von Bildschirmspuren im onFragmentAttached() Callback starten und die Aufzeichnung im onFragmentDetached() Callback beenden.

MainActivity.java

private final FragmentManager.FragmentLifecycleCallbacks fragmentLifecycleCallbacks =
       new FragmentManager.FragmentLifecycleCallbacks() {

           @Override
           public void onFragmentAttached(@NonNull FragmentManager fm, @NonNull Fragment f, @NonNull Context context) {
               super.onFragmentAttached(fm, f, context);

               // TODO (3): Start recording the screen traces as soon as the Fragment is
               //  attached to its host Activity.
               if (FRAGMENT_TAG.equals(f.getTag()) && screenTrace.isScreenTraceSupported()) {
                   screenTrace.recordScreenTrace();
               }
           }

           @Override
           public void onFragmentDetached(@NonNull FragmentManager fm, @NonNull Fragment f) {
               super.onFragmentDetached(fm, f);

               // TODO (4): Stop recording the screen traces as soon as the Fragment is
               //  detached from its host Activity.
               if (FRAGMENT_TAG.equals(f.getTag()) && screenTrace.isScreenTraceSupported()) {
                   screenTrace.sendScreenTrace();
               }

               // Unregister Fragment lifecycle callbacks after the Fragment is detached
               fm.unregisterFragmentLifecycleCallbacks(fragmentLifecycleCallbacks);
           }
       };
  1. Führen Sie die App erneut aus. Tippen Sie dann auf die Schaltfläche LOAD FRAGMENT LADEN. Warten Sie einige Sekunden und klicken Sie dann auf die back button „Zurück“ in der unteren Navigationsleiste.

Filtern Sie den Logcat mit " Logging Trace metric " und suchen Sie dann nach Protokollen wie unten:

I/FirebasePerformance: Logging trace metric: _st_MainActivity-TestFragment (duration: XXXms)

Filtern Sie den Logcat mit " FireperfViews " und suchen Sie dann nach Protokollen wie unten:

D/FireperfViews: sendScreenTrace MainActivity-TestFragment, name: _st_MainActivity-TestFragment, total_frames: XX, slow_frames: XX, frozen_frames: XX

🎉 Herzlichen Glückwunsch! Sie haben erfolgreich die langsamen/eingefrorenen Frames für ein Fragment gemessen und diese Daten an Firebase Performance Monitoring gemeldet. Wir sehen uns die aufgezeichneten Metriken später in diesem Codelab in der Firebase-Konsole an.

9. Überprüfen Sie die Messwerte in der Firebase-Konsole

  1. Klicken Sie im Logcat auf die URL der Firebase-Konsole, um die Detailseite für eine Ablaufverfolgung aufzurufen. ceb9d5ba51bb6e89.jpeg

Wählen Sie alternativ in der Firebase-Konsole das Projekt mit Ihrer App aus. Suchen Sie im linken Bereich den Abschnitt Release & Monitor und klicken Sie dann auf Performance .

  • Scrollen Sie auf der Hauptregisterkarte Dashboard nach unten zur Ablaufverfolgungstabelle und klicken Sie dann auf die Registerkarte Benutzerdefinierte Ablaufverfolgungen. In dieser Tabelle sehen Sie die benutzerdefinierten Code-Traces, die wir zuvor hinzugefügt haben, sowie einige sofort einsatzbereite Traces , z. B. _app_start -Trace.
  • Suchen Sie Ihre beiden Ablaufverfolgungen für benutzerdefinierten Code, TestActivity-LoadTime und TestFragment-LoadTime . Klicken Sie bei beiden auf die Dauer , um weitere Details zu den gesammelten Daten anzuzeigen.

a0d8455c5269a590.png

  1. Die Detailseite für den Custom Code Trace zeigt Ihnen Informationen über die Dauer des Traces (dh die gemessene Ladezeit).

5e92a307b7410d8b.png

  1. Sie können auch die Leistungsdaten für Ihre benutzerdefinierte Bildschirmaufzeichnung anzeigen.
  • Gehen Sie zurück zur Hauptregisterkarte Dashboard , scrollen Sie nach unten zur Ablaufverfolgungstabelle und klicken Sie dann auf die Registerkarte Bildschirmwiedergabe . In dieser Tabelle sehen Sie die benutzerdefinierten Bildschirmablaufverfolgungen, die wir zuvor hinzugefügt haben, sowie alle vorkonfigurierten Bildschirmablaufverfolgungen , z. B. die MainActivity -Ablaufverfolgung.
  • Suchen Sie Ihre benutzerdefinierte Bildschirmablaufverfolgung, MainActivity-TestFragment . Klicken Sie auf den Spurnamen, um die aggregierten Daten von langsamem Rendering und eingefrorenen Frames anzuzeigen.

ee7890c7e2c28740.png

10. Herzlichen Glückwunsch

Herzliche Glückwünsche! Sie haben die Ladezeit und die Bildschirmdarstellungsleistung einer Aktivität und eines Fragments mithilfe der Firebase-Leistungsüberwachung erfolgreich gemessen!

Was Sie erreicht haben

Was kommt als nächstes

Firebase Performance bietet neben benutzerdefinierten Traces weitere Möglichkeiten zur Leistungsmessung Ihrer App. Es misst automatisch die App-Startzeit, App-im-Vordergrund- und App-im-Hintergrund-Leistungsdaten . Es ist an der Zeit, dass Sie diese Messwerte in der Firebase Console überprüfen .

Außerdem bietet Firebase Performance eine automatische HTTP/S-Netzwerkanforderungsüberwachung . Damit können Sie Netzwerkanfragen einfach instrumentieren, ohne eine einzige Codezeile zu schreiben. Können Sie versuchen, einige Netzwerkanfragen von Ihrer App zu senden und die Messwerte in der Firebase-Konsole zu finden?

Bonus

Jetzt, da Sie wissen, wie Sie die Ladezeit und die Bildschirmwiedergabeleistung Ihrer Aktivität/Ihres Fragments mithilfe von benutzerdefinierten Code-Traces messen, können Sie unsere Open-Source-Codebasis erkunden, um zu sehen, ob Sie diese Metriken für jede Aktivität/jedes Fragment sofort erfassen können das ist ein Teil der App? Schicken Sie gerne die PR, wenn Sie möchten :-)

11. Bonuslernen

Wenn Sie verstehen, was während des Ladens einer Aktivität passiert, können Sie die Leistungsmerkmale Ihrer App besser verstehen. In einem früheren Schritt haben wir auf hoher Ebene beschrieben, was während des Ladens einer Aktivität passiert, aber das folgende Diagramm beschreibt jede Phase viel detaillierter.

cd61c1495fad7961.png