Wykrywanie rozpoczęcia i zakończenia aktywności przez użytkowników

Może być konieczne zaprojektowanie aplikacji tak, aby rozpoznawała, kiedy użytkownik rozpoczyna lub kończy określoną aktywność, np. spacer, jazdę na rowerze lub jazdę samochodem. Na przykład aplikacja do śledzenia przebiegu może zacząć śledzić kilometry, gdy użytkownik zacznie jechać, a aplikacja do obsługi wiadomości może wyciszyć wszystkie rozmowy, dopóki użytkownik nie przestanie prowadzić.

Interfejs Activity Recognition Transition API może służyć do wykrywania zmian w aktywności użytkownika. Aplikacja subskrybuje przejście między interesującymi aktywnościami, a interfejs API powiadamia ją tylko wtedy, gdy jest to konieczne. Na tej stronie dowiesz się, jak korzystać z interfejsu Activity Recognition Transition API, zwanego też w skrócie Transition API.

Konfigurowanie projektu

Aby używać interfejsu Transition API w aplikacji, musisz zadeklarować zależność od interfejsu Google Location and Activity Recognition w wersji 12.0.0 lub nowszej i określić uprawnienie com.google.android.gms.permission.ACTIVITY_RECOGNITION w pliku manifestu aplikacji.

  1. Aby zadeklarować zależność od interfejsu API, dodaj odwołanie do repozytorium Google Maven i wpis implementacji do com.google.android.gms:play-services-location:12.0.0 w sekcji zależności pliku build.gradle aplikacji. Więcej informacji znajdziesz w artykule Konfigurowanie Usług Google Play.
  2. Aby określić uprawnienie com.google.android.gms.permission.ACTIVITY_RECOGNITION, dodaj element <uses-permission> w pliku manifestu aplikacji, jak pokazano w tym przykładzie:

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

Rejestrowanie się w celu otrzymywania aktualizacji dotyczących przejść między aktywnościami

Aby zacząć otrzymywać powiadomienia o zmianach aktywności, musisz zaimplementować te elementy:

Aby utworzyć obiekt ActivityTransitionRequest, musisz utworzyć listę obiektów ActivityTransition, które reprezentują przejście, o którym chcesz otrzymywać powiadomienia. Obiekt ActivityTransition zawiera te dane:

Poniższy kod pokazuje, jak utworzyć listę obiektów ActivityTransition:

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

Obiekt ActivityTransitionRequest możesz utworzyć, przekazując listę ActivityTransitions do klasy ActivityTransitionRequest, jak w tym przykładzie:

Kotlin

val request = ActivityTransitionRequest(transitions)

Java

ActivityTransitionRequest request = new ActivityTransitionRequest(transitions);

Możesz zarejestrować się, aby otrzymywać aktualizacje dotyczące przejścia między aktywnościami, przekazując instancję ActivityTransitionRequest i obiekt PendingIntent do metody requestActivityTransitionUpdates(). Metoda requestActivityTransitionUpdates() zwraca obiekt Task, który możesz sprawdzić pod kątem powodzenia lub niepowodzenia, jak pokazano w tym przykładowym kodzie:

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

Po zarejestrowaniu się w celu otrzymywania aktualizacji dotyczących przejścia między aktywnościami aplikacja będzie otrzymywać powiadomienia w zarejestrowanym elemencie PendingIntent.

Przetwarzanie zdarzeń przejścia aktywności

Gdy nastąpi żądane przejście między aktywnościami, aplikacja otrzyma wywołanie zwrotne Intent. Możesz wyodrębnić obiekt ActivityTransitionResult z Intent, który zawiera listę obiektów ActivityTransitionEvent. Zdarzenia są uporządkowane chronologicznie. Jeśli na przykład aplikacja żąda typu aktywności IN_VEHICLE przy przejściach ACTIVITY_TRANSITION_ENTER i ACTIVITY_TRANSITION_EXIT, otrzymuje obiekt ActivityTransitionEvent, gdy użytkownik zaczyna prowadzić samochód, i kolejny, gdy użytkownik przechodzi do innej aktywności.

Aby zaimplementować wywołanie zwrotne, utwórz podklasę BroadcastReceiver i zaimplementuj metodę onReceive, która pobiera listę zdarzeń przejścia aktywności. Więcej informacji znajdziesz w sekcji Transmisje. Poniższy przykład pokazuje, jak wdrożyć metodę onReceive:

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

Wyrejestrowywanie się z aktualizacji dotyczących zmian aktywności

Możesz wyrejestrować się z otrzymywania aktualizacji dotyczących przejść między aktywnościami, wywołując metodę removeActivityTransitionUpdates() klasy ActivityRecognitionClient i przekazując obiekt PendingIntent jako parametr, jak w tym przykładzie:

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

Dodatkowe materiały

Więcej informacji o korzystaniu z interfejsu API rozpoznawania aktywności użytkownika znajdziesz w tych materiałach:

Przykłady

Przykładowa aplikacja pokazująca sprawdzone metody rozpoznawania aktywności użytkownika.