Erkennen, wann Nutzer eine Aktivität starten oder beenden

Möglicherweise ist es erforderlich, dass deine App erkennt, wenn ein Nutzer eine bestimmte Aktivität wie Gehen, Radfahren oder Autofahren beginnt oder beendet. Eine App zur Erfassung von Kilometerständen könnte beispielsweise mit der Erfassung beginnen, wenn ein Nutzer losfährt, oder eine Messaging-App könnte alle Unterhaltungen stummschalten, bis der Nutzer nicht mehr fährt.

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

Projekt einrichten

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, Version 12.0.0 oder höher, deklarieren und die Berechtigung com.google.android.gms.permission.ACTIVITY_RECOGNITION im App-Manifest angeben.

  1. Wenn Sie eine Abhängigkeit von der API deklarieren möchten, fügen Sie einen Verweis auf das Google Maven-Repository und einen Implementierungseintrag für com.google.android.gms:play-services-location:12.0.0 im Abschnitt „dependencies“ der Datei build.gradle Ihrer App hinzu. Weitere Informationen finden Sie unter Google Play-Dienste einrichten.
  2. 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 zu Aktivitätsübergängen registrieren

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

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

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());

Sie können ein ActivityTransitionRequest-Objekt erstellen, indem Sie die Liste der ActivityTransitions an die Klasse ActivityTransitionRequest übergeben, wie im folgenden Beispiel gezeigt:

Kotlin

val request = ActivityTransitionRequest(transitions)

Java

ActivityTransitionRequest request = new ActivityTransitionRequest(transitions);

Sie können sich für Updates zu Aktivitätsübergängen registrieren, indem Sie Ihre Instanz von ActivityTransitionRequest und Ihr PendingIntent-Objekt 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 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
        }
    }
);

Nachdem Sie sich für Updates zu Aktivitätsübergängen registriert haben, erhält Ihre App Benachrichtigungen im registrierten PendingIntent.

Ereignisse für Übergänge zwischen Aktivitäten verarbeiten

Wenn der angeforderte Aktivitätsübergang erfolgt, erhält Ihre App einen Intent-Callback. Sie können ein ActivityTransitionResult-Objekt aus dem Intent extrahieren, das eine Liste von ActivityTransitionEvent-Objekten enthält. Die Ereignisse sind chronologisch geordnet. 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 mit dem Fahren beginnt, und ein weiteres, wenn der Nutzer zu einer anderen Aktivität wechselt.

Sie können Ihren Callback implementieren, indem Sie eine Unterklasse von BroadcastReceiver erstellen und die Methode onReceive implementieren, um die Liste der Ereignisse für Aktivitätsübergänge abzurufen. Weitere Informationen finden Sie unter Übertragungen. 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....
        }
    }
}

Updates zu Aktivitätsübergängen abbestellen

Sie können die Registrierung für Updates zu 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());
        }
    }
);

Zusätzliche Ressourcen

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

Beispiele

Beispiel, das Best Practices für die Erkennung von Nutzeraktivitäten veranschaulicht.