Diese Seite wurde von der Cloud Translation API übersetzt.

Erkennen, wann Nutzer eine Aktivität starten oder beenden

Möglicherweise müssen Sie Ihre App so entwickeln, dass sie erkennt, wann ein Nutzer eine bestimmte Aktivität, z. B. Gehen, Radfahren oder Autofahren, startet oder stoppt. Eine solche App könnte zum Beispiel damit beginnen, Meilen zu verfolgen, wenn ein Nutzer losfährt, oder eine Nachrichten-App könnte alle Unterhaltungen stummschalten, bis der Nutzer die Fahrt beendet.

Mit der Activity Recognition Transition API können Änderungen in den Aktivitäten des Nutzers erkannt werden. Ihre App abonniert einen Übergang zu relevanten Aktivitäten und die API benachrichtigt Ihre App nur bei Bedarf. Auf dieser Seite wird beschrieben, wie Sie die Activity Recognition Transition API, kurz Transition API, verwenden.

Projekt einrichten

Wenn du die Transition API in deiner App verwenden möchtest, musst du eine Abhängigkeit von der Google Location and Activity Recognition API ab Version 12.0.0 deklarieren und die Berechtigung com.google.android.gms.permission.ACTIVITY_RECOGNITION im App-Manifest angeben.

Zum Deklarieren einer Abhängigkeit zur API fügen Sie einen Verweis auf das Google Maven-Repository hinzu und fügen com.google.android.gms:play-services-location:12.0.0 dem Abhängigkeiten-Bereich der App-Datei build.gradle einen Implementierungseintrag hinzu. Weitere Informationen finden Sie unter Google Play-Dienste einrichten.

Wenn Sie die Berechtigung com.google.android.gms.permission.ACTIVITY_RECOGNITION angeben möchten, fügen Sie dem App-Manifest ein <uses-permission>-Element hinzu, wie im folgenden Beispiel gezeigt:

 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
         package="com.example.myapp">

   <uses-permission android:name="com.google.android.gms.permission.ACTIVITY_RECOGNITION" />
   …
 </manifest>

Für Updates zur Aktivitätsumstellung registrieren

Damit du Benachrichtigungen zu Aktivitätsübergängen erhalten kannst, musst du Folgendes implementieren:

Ein ActivityTransitionRequest-Objekt, das den Typ der Aktivität und des Übergangs angibt.
Ein PendingIntent-Callback, bei dem deine App Benachrichtigungen empfängt. Weitere Informationen finden Sie unter Ausstehenden Intent verwenden.

Zum Erstellen des ActivityTransitionRequest-Objekts müssen Sie eine Liste mit ActivityTransition-Objekten erstellen, die den Übergang darstellen, für den Sie Benachrichtigungen erhalten möchten. Ein ActivityTransition-Objekt enthält die folgenden Daten:

Ein Aktivitätstyp, der durch die Klasse DetectedActivity dargestellt wird. Die Transition API unterstützt die folgenden Aktivitäten:
Ein Übergangstyp von ACTIVITY_TRANSITION_ENTER oder ACTIVITY_TRANSITION_EXIT. Weitere Informationen finden Sie in der Klasse ActivityTransition.

Der folgende Code zeigt, wie eine Liste von ActivityTransition-Objekten erstellt wird:

Kotlin

val transitions = mutableListOf<ActivityTransition>()

transitions +=
        ActivityTransition.Builder()
          .setActivityType(DetectedActivity.IN_VEHICLE)
          .setActivityTransition(ActivityTransition.ACTIVITY_TRANSITION_ENTER)
          .build()

transitions +=
        ActivityTransition.Builder()
          .setActivityType(DetectedActivity.IN_VEHICLE)
          .setActivityTransition(ActivityTransition.ACTIVITY_TRANSITION_EXIT)
          .build()

transitions +=
        ActivityTransition.Builder()
          .setActivityType(DetectedActivity.WALKING)
          .setActivityTransition(ActivityTransition.ACTIVITY_TRANSITION_EXIT)
          .build()

Java

List<ActivityTransition> transitions = new ArrayList<>();

transitions.add(
        new ActivityTransition.Builder()
          .setActivityType(DetectedActivity.IN_VEHICLE)
          .setActivityTransition(ActivityTransition.ACTIVITY_TRANSITION_ENTER)
          .build());

transitions.add(
        new ActivityTransition.Builder()
          .setActivityType(DetectedActivity.IN_VEHICLE)
          .setActivityTransition(ActivityTransition.ACTIVITY_TRANSITION_EXIT)
          .build());

transitions.add(
        new ActivityTransition.Builder()
          .setActivityType(DetectedActivity.WALKING)
          .setActivityTransition(ActivityTransition.ACTIVITY_TRANSITION_EXIT)
          .build());

Zum Erstellen eines ActivityTransitionRequest-Objekts übergeben Sie die Liste von ActivityTransitions an die Klasse ActivityTransitionRequest, wie im folgenden Beispiel gezeigt:

Kotlin

val request = ActivityTransitionRequest(transitions)

Java

ActivityTransitionRequest request = new ActivityTransitionRequest(transitions);

Sie können sich für Aktualisierungen der Aktivitätsmigration registrieren. Übergeben Sie dazu Ihre Instanz von ActivityTransitionRequest und das Objekt PendingIntent an die Methode requestActivityTransitionUpdates(). Die Methode requestActivityTransitionUpdates() gibt ein Objekt Task zurück, das Sie auf Erfolg oder Fehler prüfen können, wie im folgenden Codebeispiel gezeigt:

Kotlin

// myPendingIntent is the instance of PendingIntent where the app receives callbacks.
val task = ActivityRecognition.getClient(context)
        .requestActivityTransitionUpdates(request, myPendingIntent)

task.addOnSuccessListener {
    // Handle success
}

task.addOnFailureListener { e: Exception ->
    // Handle error
}

Java

// myPendingIntent is the instance of PendingIntent where the app receives callbacks.
Task<Void> task = ActivityRecognition.getClient(context)
          .requestActivityTransitionUpdates(request, myPendingIntent);

task.addOnSuccessListener(
    new OnSuccessListener<Void>() {
        @Override
        public void onSuccess(Void result) {
            // Handle success
        }
    }
);

task.addOnFailureListener(
    new OnFailureListener() {
        @Override
        public void onFailure(Exception e) {
            // Handle error
        }
    }
);

Nach der Registrierung für Updates zur Aktivitätsumstellung erhält Ihre App Benachrichtigungen im registrierten PendingIntent.

Übergangsereignisse für Prozessaktivitäten

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

Zum Implementieren des Callbacks kannst du eine abgeleitete Klasse von BroadcastReceiver erstellen und die Methode onReceive() implementieren, um die Liste der Aktivitätsübergangsereignisse abzurufen. Weitere Informationen finden Sie unter Broadcasts. Das folgende Beispiel zeigt, wie die Methode onReceive() implementiert wird:

Kotlin

override fun onReceive(context: Context, intent: Intent) {
    if (ActivityTransitionResult.hasResult(intent)) {
        val result = ActivityTransitionResult.extractResult(intent)!!
        for (event in result.transitionEvents) {
            // chronological sequence of events....
        }
    }
}

Java

@Override
public void onReceive(Context context, Intent intent) {
    if (ActivityTransitionResult.hasResult(intent)) {
        ActivityTransitionResult result = ActivityTransitionResult.extractResult(intent);
        for (ActivityTransitionEvent event : result.getTransitionEvents()) {
            // chronological sequence of events....
        }
    }
}

Registrierung für Updates zur Aktivitätsumstellung aufheben

Sie können die Registrierung für Aktualisierungen von Aktivitätsübergängen aufheben, indem Sie die Methode removeActivityTransitionUpdates() von ActivityRecognitionClient aufrufen und Ihr PendingIntent-Objekt als Parameter übergeben, wie im folgenden Beispiel gezeigt:

Kotlin

// myPendingIntent is the instance of PendingIntent where the app receives callbacks.
val task = ActivityRecognition.getClient(context)
        .removeActivityTransitionUpdates(myPendingIntent)

task.addOnSuccessListener {
    myPendingIntent.cancel()
}

task.addOnFailureListener { e: Exception ->
    Log.e("MYCOMPONENT", e.message)
}

Java

// myPendingIntent is the instance of PendingIntent where the app receives callbacks.
Task<Void> task = ActivityRecognition.getClient(context)
        .removeActivityTransitionUpdates(myPendingIntent);

task.addOnSuccessListener(
    new OnSuccessListener<Void>() {
        @Override
        public void onSuccess(Void result) {
            myPendingIntent.cancel();
        }
    }
);

task.addOnFailureListener(
    new OnFailureListener() {
        @Override
        public void onFailure(Exception e) {
            Log.e("MYCOMPONENT", e.getMessage());
        }
    }
);

Weitere Informationen

Weitere Informationen zur Verwendung der API zur Erkennung der Nutzeraktivität finden Sie in den folgenden Materialien:

Produktproben

Beispiel für Best Practices zur Erkennung von Nutzeraktivitäten

Zurück

Geofences erstellen und überwachen

Weiter

Standort für Akku optimieren