Codelab zur Activity Recognition Transition API

1. Einführung

Wir tragen unsere Smartphones überall mit uns herum, aber bis jetzt war es für Apps schwierig, die Nutzung an die sich ständig ändernde Umgebung und Aktivität der Nutzer anzupassen.

Dazu mussten Entwickler in der Vergangenheit wertvolle Entwicklungszeit darauf verwenden, verschiedene Signale (Standort, Sensor usw.) zu kombinieren, um zu ermitteln, wann eine Aktivität wie Gehen oder Fahren begonnen oder beendet wurde. Schlimmer noch: Wenn Apps unabhängig und kontinuierlich nach Änderungen der Nutzeraktivität suchen, verkürzt sich die Akkulaufzeit.

Die Activity Recognition Transition API löst diese Probleme, da sie eine einfache API bietet, die die gesamte Verarbeitung für Sie übernimmt und Ihnen nur das mitteilt, was Sie wirklich interessiert: wann sich die Aktivität eines Nutzers geändert hat. Ihre App abonniert einfach einen Übergang zu Aktivitäten, die Sie interessieren, und die API benachrichtigt Sie über die Änderungen.

Eine Messaging-App kann beispielsweise fragen: „Informiere mich, wenn der Nutzer ein Fahrzeug bestiegen oder verlassen hat“, um den Status des Nutzers auf „Beschäftigt“ zu setzen. Ähnlich kann eine App zur Parkplatzerkennung fragen: „Sag mir, wenn der Nutzer aus einem Fahrzeug ausgestiegen und zu Fuß unterwegs ist“, um den Parkplatz des Nutzers zu speichern.

In diesem Codelab erfahren Sie, wie Sie mit der Activity Recognition Transition API feststellen können, wann ein Nutzer eine Aktivität wie Gehen oder Laufen startet oder beendet.

Voraussetzungen

Sie sollten mit der Android-Entwicklung und mit Rückrufen vertraut sein.

Lerninhalte

• Für Aktivitätsübergänge registrieren
• Verarbeitung dieser Ereignisse
• Registrierung für Aktivitätsübergänge aufheben, wenn sie nicht mehr benötigt werden

Voraussetzungen

• Android Studio Bumblebee
• Ein Android-Gerät oder ‑Emulator

2. Erste Schritte

Repository des Starterprojekts klonen

Damit Sie so schnell wie möglich loslegen können, haben wir ein Startprojekt für Sie vorbereitet, auf dem Sie aufbauen können. Wenn Sie Git installiert haben, können Sie einfach den folgenden Befehl ausführen. Sie können das prüfen, indem Sie git --version in das Terminal bzw. die Befehlszeile eingeben und prüfen, ob der Befehl richtig ausgeführt wird.

 git clone https://github.com/android/codelab-activity_transitionapi

Wenn Sie kein Git haben, können Sie das Projekt als ZIP-Datei herunterladen:

file_downloadZip-Datei herunterladen

Projekt importieren

Starten Sie Android Studio und wählen Sie auf dem Begrüßungsbildschirm die Option „Vorhandenes Android Studio-Projekt öffnen“ aus. Öffnen Sie dann das Projektverzeichnis.

Nach dem Laden des Projekts wird möglicherweise eine Warnung angezeigt, dass Git nicht alle lokalen Änderungen erfasst. Sie können auf Ignorieren oder oben rechts auf das X klicken. Sie werden keine Änderungen zurück in das Git-Repository übertragen.

Wenn Sie sich in der Ansicht Android befinden, sollte links oben im Projektfenster ungefähr das Bild unten zu sehen sein. Wenn Sie sich in der Projektansicht befinden, müssen Sie das Projekt maximieren, um dieselben Informationen zu sehen.

Es gibt zwei Ordnersymbole (base und complete). Jedes davon wird als „Modul“ bezeichnet.

Es kann einige Sekunden dauern, bis Android Studio das Projekt zum ersten Mal im Hintergrund kompiliert. In der Statusleiste unten in Android Studio wird währenddessen ein rotierendes Ladesymbol angezeigt:

Wir empfehlen, zu warten, bis dieser Vorgang abgeschlossen ist, bevor Sie Codeänderungen vornehmen. Dadurch kann Android Studio alle erforderlichen Komponenten abrufen.

Wenn Sie die Aufforderung „Neu laden, damit die Sprachänderungen wirksam werden?“ oder eine ähnliche Meldung sehen, wählen Sie „Ja“ aus.

Startprojekt

Alles klar, Sie können jetzt die Aktivitätserkennung hinzufügen. Wir verwenden das Modul base, das der Ausgangspunkt für dieses Codelab ist. Mit anderen Worten: Sie fügen base Code aus jedem Schritt hinzu.

Das complete-Modul kann verwendet werden, um Ihre Arbeit zu überprüfen oder als Referenz zu verwenden, wenn Probleme auftreten.

Übersicht über die wichtigsten Komponenten:

• MainActivity: Enthält den gesamten Code, der für die Aktivitätserkennung erforderlich ist.

Emulator einrichten

Hilfe beim Einrichten eines Android-Emulators finden Sie im Artikel App ausführen.

Startprojekt ausführen

Führen wir die App aus.

• Verbinden Sie Ihr Android-Gerät mit dem Computer oder starten Sie einen Emulator.
• Wählen Sie in der Symbolleiste die base-Konfiguration aus dem Drop-down-Menü aus und klicken Sie neben ihr auf das grüne Dreieck (Ausführen):

• Die Anwendung sollte unten angezeigt werden:

• Die App tut jetzt nichts weiter, als eine Nachricht auszugeben. Jetzt fügen wir die Aktivitätserkennung hinzu.

Zusammenfassung

In diesem Schritt haben Sie Folgendes gelernt:

• Allgemeine Einrichtung für das Codelab
• Die Grundlagen unserer App
• So stellen Sie Ihre App bereit.

3. Bibliothek prüfen und Manifest Berechtigung hinzufügen

Wenn Sie die Transition API in Ihrer App verwenden möchten, müssen Sie eine Abhängigkeit von der Google Location and Activity Recognition API erklären und die Berechtigung „com.google.android.gms.permission.ACTIVITY_RECOGNITION“ im App-Manifest angeben.

1. Suchen Sie in der Datei „build.gradle“ nach TODO: Review play services library required for activity recognition (TODO: Play-Dienste-Bibliothek für die Aktivitätserkennung überprüfen). Für diesen Schritt (Schritt 1) müssen Sie nichts weiter tun. Prüfen Sie nur die erforderliche Abhängigkeit. Das sollte so aussehen:

    // TODO: Review play services library required for activity recognition.
    implementation 'com.google.android.gms:play-services-location:19.0.1'

2. Suchen Sie im base-Modul im AndroidManifest.xml nach TODO: Add both activity recognition permissions to the manifest (TODO: Manifest die beiden Berechtigungen für die Aktivitätserkennung hinzufügen) und fügen Sie dem <manifest>-Element den folgenden Code hinzu.

<!-- TODO: Add both activity recognition permissions to the manifest. -->
<!-- Required for 28 and below. -->
<uses-permission android:name="com.google.android.gms.permission.ACTIVITY_RECOGNITION" />
<!-- Required for 29+. -->
<uses-permission android:name="android.permission.ACTIVITY_RECOGNITION" />

Ihr Code sollte jetzt in etwa so aussehen:

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
         package="com.example.myapp">
<!-- TODO: Add both activity recognition permissions to the manifest. -->
<!-- Required for 28 and below. -->
<uses-permission android:name="com.google.android.gms.permission.ACTIVITY_RECOGNITION" />
<!-- Required for 29+. -->
<uses-permission android:name="android.permission.ACTIVITY_RECOGNITION" />

  ...
</manifest>

Wie Sie in den Kommentaren sehen, müssen Sie für Android 10 eine zweite Berechtigung hinzufügen. Dies ist für die Laufzeitberechtigung erforderlich, die in API-Version 29 hinzugefügt wurde.

Fertig! Ihre App kann jetzt die Aktivitätserkennung unterstützen. Dazu müssen wir nur den Code hinzufügen.

App ausführen

Führen Sie Ihre App über Android Studio aus. Sie sollte genau so aussehen. Wir haben noch keinen Code zum Erfassen von Übergängen hinzugefügt. Das kommt im nächsten Abschnitt.

4. Laufzeitberechtigungen unter Android prüfen/anfordern

Für API-Version 28 und niedriger sind wir abgedeckt. Ab API-Version 29 müssen wir jedoch Laufzeitberechtigungen unterstützen:

• In der MainActivity.java wird geprüft, ob der Nutzer Android 10 (29) oder höher verwendet. Ist das der Fall, werden die Berechtigungen für die Aktivitätserkennung geprüft.
• Wenn die Berechtigungen nicht gewährt werden, wird der Nutzer zu einem Splashscreen (PermissionRationalActivity.java) weitergeleitet, in dem erklärt wird, warum die App die Berechtigung benötigt. Dort kann er sie genehmigen.

Code zur Prüfung der Android-Version überprüfen

Suche im Modul base nach TODO: Überprüfung der Geräte mit Android 10 (29+) prüfen in MainActivity.java. Sie sollten dieses Code-Snippet sehen.

Hinweis: Für diesen Abschnitt sind keine Maßnahmen erforderlich.

// TODO: Review check for devices with Android 10 (29+).
private boolean runningQOrLater =
    android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.Q;

Wie bereits erwähnt, benötigen Sie unter Android 10 und höher die Genehmigung für die Laufzeitberechtigung android.permission.ACTIVITY_RECOGNITION. Anhand dieser einfachen Prüfung entscheiden wir, ob wir die Laufzeitberechtigungen prüfen müssen.

Prüfen Sie bei Bedarf die Laufzeitberechtigungsprüfung für die Aktivitätserkennung.

Suchen Sie im Modul base in MainActivity.java nach TODO: Berechtigungsprüfung für Version 29 und höher überprüfen. Sie sollten dieses Code-Snippet sehen.

Hinweis: Für diesen Abschnitt sind keine Maßnahmen erforderlich.

// TODO: Review permission check for 29+.
if (runningQOrLater) {

   return PackageManager.PERMISSION_GRANTED == ActivityCompat.checkSelfPermission(
           this,
           Manifest.permission.ACTIVITY_RECOGNITION
   );
} else {
   return true;
}

Wir verwenden die Variable, die wir im vorherigen Schritt erstellt haben, um zu prüfen, ob wir Laufzeitberechtigungen prüfen müssen.

Bei Version Q und höher prüfen und geben wir das Ergebnis für die Laufzeitberechtigung zurück. Dies ist Teil einer größeren Methode namens activityRecognitionPermissionApproved(), mit der der Entwickler mit nur einem einfachen Aufruf erfährt, ob eine Berechtigung angefordert werden muss oder nicht.

Laufzeitberechtigungen anfordern und Übergänge bei der Aktivitätserkennung aktivieren/deaktivieren

Suchen Sie im Modul base in MainActivity.java nach TODO: Aktivitäts-Tracking aktivieren/deaktivieren und bei Bedarf um Berechtigungen bitten. Fügen Sie den Code unten nach dem Kommentar ein.

// TODO: Enable/Disable activity tracking and ask for permissions if needed.
if (activityRecognitionPermissionApproved()) {

   if (activityTrackingEnabled) {
      disableActivityTransitions();

   } else {
      enableActivityTransitions();
   }

} else {  
   // Request permission and start activity for result. If the permission is approved, we
   // want to make sure we start activity recognition tracking.
   Intent startIntent = new Intent(this, PermissionRationalActivity.class);
   startActivityForResult(startIntent, 0);

}

Hier wird gefragt, ob die Aktivitätserkennung genehmigt ist. Wenn dies der Fall ist und die Aktivitätserkennung bereits aktiviert ist, deaktivieren wir sie. Andernfalls aktivieren wir sie.

Wenn die Berechtigung nicht genehmigt wird, werden Nutzer zum Startbildschirm weitergeleitet, auf dem erklärt wird, warum wir die Berechtigung benötigen, und sie sie aktivieren können.

Code für die Berechtigungsanfrage prüfen

Suchen Sie im Modul base in PermissionRationalActivity.java nach TODO: Permission request for activity recognition review (TODO: Berechtigungsanfrage für die Aktivitätserkennung prüfen). Sie sollten dieses Code-Snippet sehen.

Hinweis: Für diesen Abschnitt sind keine Maßnahmen erforderlich.

// TODO: Review permission request for activity recognition.
ActivityCompat.requestPermissions(
             this,
             new String[]{Manifest.permission.ACTIVITY_RECOGNITION},
             PERMISSION_REQUEST_ACTIVITY_RECOGNITION)

Dies ist der wichtigste Teil der Aktivität und der Teil, den Sie überprüfen sollten. Der Code löst die Anfrage der Berechtigung aus, wenn der Nutzer sie anfordert.

Außerdem wird in der Klasse PermissionRationalActivity.java eine Begründung dafür angezeigt, warum der Nutzer die Berechtigung zur Aktivitätserkennung genehmigen sollte (Best Practice). Der Nutzer kann entweder auf die Schaltfläche Nein, danke oder auf die Schaltfläche Weiter klicken (wodurch der Code oben ausgelöst wird).

Wenn Sie mehr darüber erfahren möchten, können Sie sich die Datei ansehen.

5. Empfänger für Aktivitätsübergänge registrieren/abmelden

Bevor wir den Code für die Aktivitätserkennung einrichten, möchten wir sicherstellen, dass unsere Aktivität mit den vom System ausgelösten Übergangsaktionen umgehen kann.

BroadcastReceiver für den Übergang erstellen

Suchen Sie im Modul base in MainActivity.java nach TODO: Create a BroadcastReceiver to listen for activity transitions (TODO: BroadcastReceiver zum Überwachen von Aktivitätsübergängen erstellen). Fügen Sie das Snippet unten ein.

// TODO: Create a BroadcastReceiver to listen for activity transitions.
// The receiver listens for the PendingIntent above that is triggered by the system when an
// activity transition occurs.
mTransitionsReceiver = new TransitionsReceiver();

BroadcastReceiver für den Übergang registrieren

Suchen Sie im base-Modul in MainActivity.java nach TODO: BroadcastReceiver registrieren, um auf Aktivitätsübergänge zu hören. (Sie finden es unter onStart().) Fügen Sie das Snippet unten ein.

// TODO: Register a BroadcastReceiver to listen for activity transitions.
registerReceiver(mTransitionsReceiver, new IntentFilter(TRANSITIONS_RECEIVER_ACTION));

Jetzt haben wir eine Möglichkeit, Updates zu erhalten, wenn die Aktivitätsübergänge über das PendingIntent ausgelöst werden.

BroadcastReceiver unregister

Suchen Sie im base-Modul in MainActivity.java nach Registrierungsempfänger für Aktivitätsübergänge abmelden, wenn Nutzer die App verlässt. (Sie finden es unter onStop().) Fügen Sie das Snippet unten ein.

// TODO: Unregister activity transition receiver when user leaves the app.
unregisterReceiver(mTransitionsReceiver);

Es wird empfohlen, einen Empfänger abzumelden, wenn die Activity heruntergefahren wird.

6. Aktivitätsübergänge einrichten und Aktualisierungen anfordern

Damit Sie Benachrichtigungen zu Aktivitätsübergängen erhalten, müssen Sie Folgendes implementieren:

• Ein ActivityTransitionRequest-Objekt, das die Art der Aktivität und des Übergangs angibt.
• Ein PendingIntent-Callback, über den Ihre App Benachrichtigungen erhält. Weitere Informationen finden Sie unter Ausstehende Intents verwenden.

Liste der zu verfolgenden Aktivitätsübergänge erstellen

Um das Objekt ActivityTransitionRequest zu erstellen, müssen Sie eine Liste von ActivityTransition-Objekten erstellen, die den Übergang darstellen, den Sie erfassen möchten. Ein ActivityTransition-Objekt enthält die folgenden Daten:

1. Ein Aktivitätstyp, der durch die Klasse DetectedActivity dargestellt wird. Die Transition API unterstützt die folgenden Aktivitäten:

• IN_VEHICLE
• ON_BICYCLE
• RUNNING
• STILL
• ZU FUß

2. Ein Übergangstyp, der durch die Klasse ActivityTransition dargestellt wird. Die Übergangstypen sind:

• ACTIVITY_TRANSITION_ENTER
• ACTIVITY_TRANSITION_EXIT

Suchen Sie im Modul base in MainActivity.java nach TODO: Aktivitätsübergänge zum Erfassen hinzufügen. Fügen Sie den Code unten nach dem Kommentar ein.

// TODO: Add activity transitions to track.
activityTransitionList.add(new ActivityTransition.Builder()
        .setActivityType(DetectedActivity.WALKING)
        .setActivityTransition(ActivityTransition.ACTIVITY_TRANSITION_ENTER)
        .build());
activityTransitionList.add(new ActivityTransition.Builder()
        .setActivityType(DetectedActivity.WALKING)
        .setActivityTransition(ActivityTransition.ACTIVITY_TRANSITION_EXIT)
        .build());
activityTransitionList.add(new ActivityTransition.Builder()
        .setActivityType(DetectedActivity.STILL)
        .setActivityTransition(ActivityTransition.ACTIVITY_TRANSITION_ENTER)
        .build());
activityTransitionList.add(new ActivityTransition.Builder()
        .setActivityType(DetectedActivity.STILL)
        .setActivityTransition(ActivityTransition.ACTIVITY_TRANSITION_EXIT)
        .build());

Mit diesem Code werden die Übergänge, die wir erfassen möchten, einer zuvor leeren Liste hinzugefügt.

PendingIntent erstellen

Wie bereits erwähnt, benötigen wir eine PendingIntent, wenn wir über Änderungen an unserer ActivityTransitionRequest benachrichtigt werden möchten. Bevor wir also unsere ActivityTransitionRequest einrichten, müssen wir eine PendingIntent erstellen.

Suchen Sie im Modul base in MainActivity.java nach TODO: PendingIntent initialisieren, das ausgelöst wird, wenn ein Aktivitätsübergang auftritt. Fügen Sie den Code unten nach dem Kommentar ein.

// TODO: Initialize PendingIntent that will be triggered when a activity transition occurs.
Intent intent = new Intent(TRANSITIONS_RECEIVER_ACTION);
mActivityTransitionsPendingIntent =
        PendingIntent.getBroadcast(MainActivity.this, 0, intent, 0);

Jetzt haben wir ein PendingIntent, das wir auslösen können, wenn eine der Aktivitätsübergänge auftritt.

ActivityTransitionRequest erstellen und Aktualisierungen anfordern

Sie können ein ActivityTransitionRequest-Objekt erstellen, indem Sie die Liste der Aktivitätsübergänge an die ActivityTransitionRequest-Klasse übergeben.

Suchen Sie im Modul base in MainActivity.java nach Anfrage erstellen und auf Aktivitätsänderungen warten. Fügen Sie den Code unten nach dem Kommentar ein.

// TODO: Create request and listen for activity changes.
ActivityTransitionRequest request = new ActivityTransitionRequest(activityTransitionList);

// Register for Transitions Updates.
Task<Void> task =
        ActivityRecognition.getClient(this)
                .requestActivityTransitionUpdates(request, mActivityTransitionsPendingIntent);


task.addOnSuccessListener(
        new OnSuccessListener<Void>() {
            @Override
            public void onSuccess(Void result) {
                activityTrackingEnabled = true;
                printToScreen("Transitions Api was successfully registered.");

            }
        });
task.addOnFailureListener(
        new OnFailureListener() {
            @Override
            public void onFailure(@NonNull Exception e) {
                printToScreen("Transitions Api could NOT be registered: " + e);
                Log.e(TAG, "Transitions Api could NOT be registered: " + e);

            }
        });

Sehen wir uns den Code an. Zuerst erstellen wir aus unserer Liste der Aktivitätsübergänge eine ActivityTransitionRequest.

ActivityTransitionRequest request = new ActivityTransitionRequest(activityTransitionList);

Als Nächstes registrieren wir uns für Updates zu Aktivitätsübergängen, indem wir die Instanz von ActivityTransitionRequest und das PendingIntent-Objekt, das wir im letzten Schritt erstellt haben, an die Methode requestActivityTransitionUpdates() übergeben. Die Methode „requestActivityTransitionUpdates()“ gibt ein Task-Objekt zurück, das Sie auf Erfolg oder Fehler prüfen können, wie im nächsten Codeblock gezeigt:

// Register for Transitions Updates.
Task<Void> task =
        ActivityRecognition.getClient(this)
                .requestActivityTransitionUpdates(request, mActivityTransitionsPendingIntent);


task.addOnSuccessListener(
        new OnSuccessListener<Void>() {
            @Override
            public void onSuccess(Void result) {
                activityTrackingEnabled = true;
                printToScreen("Transitions Api was successfully registered.");

            }
        });
task.addOnFailureListener(
        new OnFailureListener() {
            @Override
            public void onFailure(@NonNull Exception e) {
                printToScreen("Transitions Api could NOT be registered: " + e);
                Log.e(TAG, "Transitions Api could NOT be registered: " + e);

            }
        });

Nachdem Sie sich für Updates zu Aktivitätsübergängen registriert haben, erhält Ihre App Benachrichtigungen über das registrierte PendingIntent. Außerdem legen wir eine Variable fest, mit der das Aktivitäts-Tracking aktiviert wird. So können wir wissen, ob es deaktiviert oder aktiviert werden soll, wenn der Nutzer noch einmal auf die Schaltfläche klickt.

Updates beim Schließen der App entfernen

Es ist wichtig, dass wir die Übergangsaktualisierungen entfernen, wenn die App geschlossen wird.

Suchen Sie im base-Modul in MainActivity.java nach Aufhören, nach Aktivitätsänderungen zu suchen. Fügen Sie den Code unten nach dem Kommentar ein.

// TODO: Stop listening for activity changes.
ActivityRecognition.getClient(this).removeActivityTransitionUpdates(mActivityTransitionsPendingIntent)
        .addOnSuccessListener(new OnSuccessListener<Void>() {
            @Override
            public void onSuccess(Void aVoid) {
                activityTrackingEnabled = false;
                printToScreen("Transitions successfully unregistered.");
            }
        })
        .addOnFailureListener(new OnFailureListener() {
            @Override
            public void onFailure(@NonNull Exception e) {
                printToScreen("Transitions could not be unregistered: " + e);
                Log.e(TAG,"Transitions could not be unregistered: " + e);
            }
        });

Jetzt müssen wir die Methode mit dem Code oben aufrufen, wenn die App heruntergefahren wird.

Suchen Sie im Modul base in MainActivity.java in onPause() nach TODO: Aktivitätsübergänge deaktivieren, wenn Nutzer die App verlässt. Fügen Sie den Code unten nach dem Kommentar ein.

// TODO: Disable activity transitions when user leaves the app.
if (activityTrackingEnabled) {
    disableActivityTransitions();
}

Das war es schon mit dem Tracking der Änderungen an Aktivitätsübergängen. Jetzt müssen wir nur noch die Updates verarbeiten.

7. Ereignisse verarbeiten

Wenn der angeforderte Aktivitätsübergang erfolgt, erhält Ihre App einen Intent-Callback. Aus dem Intent kann ein ActivityTransitionResult-Objekt extrahiert werden, das eine Liste von ActivityTransitionEvent-Objekten enthält. Die Ereignisse werden in chronologischer Reihenfolge angeordnet. Wenn eine App beispielsweise den Aktivitätstyp IN_VEHICLE für die Übergänge ACTIVITY_TRANSITION_ENTER und ACTIVITY_TRANSITION_EXIT anfordert, erhält sie ein ActivityTransitionEvent-Objekt, wenn der Nutzer losfährt, und ein weiteres, wenn er zu einer anderen Aktivität übergeht.

Fügen wir den Code hinzu, mit dem diese Ereignisse verarbeitet werden.

Suchen Sie im Modul base in MainActivity.java in onReceive() des zuvor erstellten BroadcastReceivers nach TODO: Informationen zur Aktivitätsübergangs aus Listener extrahieren. Fügen Sie den Code unten nach dem Kommentar ein.

// TODO: Extract activity transition information from listener.
if (ActivityTransitionResult.hasResult(intent)) {

    ActivityTransitionResult result = ActivityTransitionResult.extractResult(intent);

    for (ActivityTransitionEvent event : result.getTransitionEvents()) {

        String info = "Transition: " + toActivityString(event.getActivityType()) +
                " (" + toTransitionType(event.getTransitionType()) + ")" + "   " +
                new SimpleDateFormat("HH:mm:ss", Locale.US).format(new Date());

        printToScreen(info);
    }
}

Dadurch werden die Informationen in eine String umgewandelt und auf dem Bildschirm ausgegeben.

Das war's schon. Versuchen Sie, die App auszuführen.

WICHTIG: Aktivitätsänderungen lassen sich im Emulator nur schwer reproduzieren. Wir empfehlen daher, ein physisches Gerät zu verwenden.

Sie sollten Aktivitätsänderungen verfolgen können.

Die besten Ergebnisse erzielen Sie, wenn Sie die App auf einem Gerät installieren und sich bewegen. :)

8. Code prüfen

Sie haben eine einfache App erstellt, die Aktivitätsübergänge erfasst und auf dem Bildschirm auflistet.

Sie können sich den Code in seiner Gesamtheit durchlesen, um zu sehen, was Sie getan haben, und um eine bessere Vorstellung davon zu bekommen, wie alles zusammenhängt.