Erkennen, wann Nutzer eine Aktivität starten oder beenden

Es kann erforderlich sein, Ihre App so zu gestalten, dass erkannt wird, wann ein Nutzer startet oder stoppt. einer bestimmten Aktivität, wie z. B. Gehen, Radfahren oder Autofahren. Beispiel: z. B. eine App, mit der der Kilometerstand erfasst, könnte die Messaging-App alle Unterhaltungen stummschalten, bis der Nutzer anhält.

Mit der Activity Recognition Transition API können Änderungen im der Nutzeraktivität. Deine App abonniert einen Übergang bei den Aktivitäten, die dich interessieren und die API benachrichtigt Ihre App nur bei Bedarf. Auf dieser Seite erfahren Sie, wie Sie den Activity Recognition Transition API, auch kurz Transition API genannt.

Projekt einrichten

Damit Sie die Transition API in Ihrer App verwenden können, müssen Sie eine Abhängigkeit vom Google Location and Activity Recognition Version 12.0.0 oder höher und Geben Sie die Berechtigung com.google.android.gms.permission.ACTIVITY_RECOGNITION an im App-Manifest ein.

1. Fügen Sie einen Verweis zum Google-Maven hinzu, um eine Abhängigkeit für die API zu deklarieren und fügen Sie einen Implementierungseintrag com.google.android.gms:play-services-location:12.0.0 zu den Abhängigkeiten der build.gradle-Datei Ihrer App. Weitere Informationen finden Sie unter Einrichten von Google Play-Dienste.

2. Zum Festlegen der com.google.android.gms.permission.ACTIVITY_RECOGNITION Berechtigung, fügen Sie <uses-permission> -Element im App-Manifest aus, 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>
   

Registrieren, um Updates zur Aktivitätsumstellung zu erhalten

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

• Eine ActivityTransitionRequest -Objekt, das die Art der Aktivität und des Übergangs angibt.
• Ein PendingIntent-Callback, bei dem deine App einen Empfang hat Benachrichtigungen. Weitere Informationen finden Sie unter Verwenden einer ausstehenden Intent.

Um die ActivityTransitionRequest müssen Sie eine Liste mit ActivityTransition Objekte, die den Übergang darstellen, über den Sie Benachrichtigungen erhalten möchten über. Eine ActivityTransition -Objekt enthält die folgenden Daten:

• Aktivitätstyp, dargestellt durch das DetectedActivity . Die Transition API unterstützt die folgenden Aktivitäten: <ph type="x-smartling-placeholder">
  </ph>
  • IN_VEHICLE
  • ON_BICYCLE
  • RUNNING
  • STILL
  • WALKING
• Ein Übergangstyp von ACTIVITY_TRANSITION_ENTER oder ACTIVITY_TRANSITION_EXIT Weitere Informationen finden Sie in der ActivityTransition .

Der folgende Code zeigt, wie Sie eine Liste von ActivityTransition-Objekten erstellen:

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

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 eine ActivityTransitionRequest -Objekt, indem Sie die Liste von ActivityTransitions an den ActivityTransitionRequest, wie im folgenden Beispiel gezeigt:

val request = ActivityTransitionRequest(transitions)

ActivityTransitionRequest request = new ActivityTransitionRequest(transitions);

Sie können sich für Updates zur Aktivitätsumstellung registrieren, indem Sie Ihre Instanz von ActivityTransitionRequest und Ihr PendingIntent-Objekt mit der requestActivityTransitionUpdates() . Die Methode requestActivityTransitionUpdates() gibt eine Task -Objekt, das Sie auf Erfolg oder Misserfolg prüfen können, wie im folgenden Code gezeigt: Beispiel:

// 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
}

// 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 zur Aktivitätsänderung registriert haben, empfängt Benachrichtigungen im registrierten PendingIntent.

Ereignisse zur Umstellung von Prozessaktivitäten

Wenn die angeforderte Aktivitätsumstellung erfolgt, erhält deine App einen Intent-Callback. Eine ActivityTransitionResult -Objekt kann aus Intent extrahiert werden, das eine Liste von ActivityTransitionEvent Objekte. Die Ereignisse sind in chronologischer Reihenfolge sortiert. Beispiel: Anfragen für die IN_VEHICLE Aktivitätstyp auf der ACTIVITY_TRANSITION_ENTER und ACTIVITY_TRANSITION_EXIT wechselt sie, dann empfängt sie ein ActivityTransitionEvent-Objekt, wenn der Nutzer und eine weitere, wenn der Nutzer zu einer anderen Aktivität wechselt.

Du kannst deinen Callback implementieren, indem du eine Unterklasse von BroadcastReceiver erstellst und die onReceive()-Methode implementierst, um die Liste abzurufen von Aktivitätsübergangsereignissen. Weitere Informationen finden Sie unter Nachrichten an alle: Das folgende Beispiel zeigt, um die Methode onReceive() zu implementieren:

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....
        }
    }
}

@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 Updates zur Aktivitätsumstellung aufheben, indem Sie die Methode removeActivityTransitionUpdates() der Methode ActivityRecognitionClient und das Objekt PendingIntent als Parameter übergeben, wie Beispiel:

// 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)
}

// 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 hier: Materialien:

Produktproben

Beispiel zur Veranschaulichung der Best Practices für die Erkennung der Nutzeraktivität