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.
- 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.0w sekcji zależności plikubuild.gradleaplikacji. Więcej informacji znajdziesz w artykule Konfigurowanie Usług Google Play. 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:
- Obiekt
ActivityTransitionRequest, który określa typ aktywności i przejścia. - Wywołanie zwrotne
PendingIntent, w którym aplikacja otrzymuje powiadomienia. Więcej informacji znajdziesz w artykule Używanie intencji oczekującej.
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:
- Typ aktywności reprezentowany przez klasę
DetectedActivity. Interfejs Transition API obsługuje te aktywności: - Typ przejścia
ACTIVITY_TRANSITION_ENTERlubACTIVITY_TRANSITION_EXIT. Więcej informacji znajdziesz w opisie klasyActivityTransition.
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.