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

Może być konieczne zaprojektowanie aplikacji tak, aby określała, kiedy użytkownik rozpoczyna i zatrzymuje konkretną aktywność, np. spacer, jazdę na rowerze czy jazdę samochodem. Na przykład aplikacja do śledzenia odległości może zacząć śledzić mile, gdy użytkownik zaczyna jechać, a aplikacja do obsługi wiadomości może wyciszyć wszystkie rozmowy do chwili, gdy użytkownik przestanie jeździć.

Interfejs Activity Recognition Transition API może służyć do wykrywania zmian w aktywności użytkownika. Aplikacja subskrybuje zmiany w interesujących Cię aktywnościach, a interfejs API powiadamia ją tylko wtedy, gdy jest to konieczne. Na tej stronie dowiesz się, jak korzystać z interfejsu Activity Recognition Transition API (nazywanego też w skrócie API Transition API).

Konfigurowanie projektu

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

1. Aby zadeklarować zależność z interfejsem API, dodaj odniesienie do repozytorium Maven Google i dodaj wpis implementacji do com.google.android.gms:play-services-location:12.0.0 w sekcji zależności w 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>
   

Zarejestruj się, aby otrzymywać aktualizacje dotyczące przenoszenia aktywności

Aby otrzymywać powiadomienia o przeniesieniu aktywności, musisz wdrożyć te rozwiązania:

• Obiekt ActivityTransitionRequest, który określa typ działania i przejścia.
• Wywołanie zwrotne PendingIntent, podczas którego aplikacja otrzymuje powiadomienia. Więcej informacji znajdziesz w artykule o używaniu intencji oczekującej.

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

• Typ działania reprezentowany przez klasę DetectedActivity. Interfejs Transition API obsługuje te działania:
  • IN_VEHICLE
  • ON_BICYCLE
  • RUNNING
  • STILL
  • WALKING
• Typ przejścia ACTIVITY_TRANSITION_ENTER lub ACTIVITY_TRANSITION_EXIT. Więcej informacji znajdziesz w opisie klasy ActivityTransition.

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

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

Aby utworzyć obiekt ActivityTransitionRequest, przekaż listę ActivityTransitions do klasy ActivityTransitionRequest, jak w tym przykładzie:

val request = ActivityTransitionRequest(transitions)

ActivityTransitionRequest request = new ActivityTransitionRequest(transitions);

Możesz zarejestrować się w celu aktualizacji przenoszenia aktywności, przekazując wystąpienie 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:

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

Gdy zarejestrujesz się w usłudze aktualizacji związanych z przeniesieniem aktywności, Twoja aplikacja będzie otrzymywać powiadomienia w zarejestrowanych domenach (PendingIntent).

Przetwarzanie zdarzeń związanych z przeniesieniem aktywności

Gdy nastąpi przeniesienie aktywności, aplikacja otrzyma wywołanie zwrotne Intent. Obiekt ActivityTransitionResult można wyodrębnić z listy Intent, która zawiera listę obiektów ActivityTransitionEvent. Zdarzenia są uporządkowane w kolejności chronologicznej, np. jeśli aplikacja żąda typu działania IN_VEHICLE w przejściach ACTIVITY_TRANSITION_ENTER i ACTIVITY_TRANSITION_EXIT, otrzyma obiekt ActivityTransitionEvent, gdy użytkownik rozpocznie jazdę, i kolejny, gdy użytkownik przejdzie do innej aktywności.

Możesz wdrożyć wywołanie zwrotne, tworząc podklasę BroadcastReceiver i implementując metodę onReceive(), aby uzyskać listę zdarzeń przeniesienia aktywności. Więcej informacji znajdziesz w sekcji Komunikaty. Poniższy przykład pokazuje, jak wdrożyć metodę onReceive():

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

Wyrejestruj, aby otrzymywać aktualizacje dotyczące przenoszenia aktywności

Możesz wyrejestrować się do aktualizacji przenoszenia aktywności, wywołując metodę removeActivityTransitionUpdates() ActivityRecognitionClient i przekazując obiekt PendingIntent jako parametr, jak w tym przykładzie:

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

Dodatkowe materiały

Aby dowiedzieć się więcej o korzystaniu z interfejsu API rozpoznawania aktywności użytkowników, zapoznaj się z tymi materiałami:

Próbki

Przykład pokazujący sprawdzone metody rozpoznawania aktywności użytkowników.