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

Zaprojektowanie aplikacji może być konieczne, aby określić, kiedy użytkownik zaczyna, a kiedy przestaje konkretną aktywność, taką jak chodzenie, jazda na rowerze czy jazda samochodem. Na przykład plik aplikacja do śledzenia przejechanych kilometrów może zacząć śledzić mile, kiedy użytkownik rozpocznie jazdę. komunikator może ignorować wszystkie rozmowy, dopóki użytkownik nie przestanie prowadzić.

Interfejs Activity Recognition Przenoszenie API może służyć do wykrywania zmian aktywność użytkownika. Twoja aplikacja subskrybuje aktywność, która Cię interesuje a interfejs API powiadamia aplikację tylko wtedy, gdy jest to konieczne. Na tej stronie dowiesz się, jak korzystać z funkcji Activity Recognition Migrate API – w skrócie nazywanym także interfejsem Transfer API.

Konfigurowanie projektu

Aby korzystać w swojej aplikacji z interfejsu Transfer API, musisz zadeklarować zależność w parametrze Google Location and Activity Recognition w wersji 12.0.0 lub nowszej oraz określ uprawnienie com.google.android.gms.permission.ACTIVITY_RECOGNITION w manifeście aplikacji.

1. Aby zadeklarować zależność do interfejsu API, dodaj odwołanie do narzędzia Google Maven i dodaj wpis implementacji do com.google.android.gms:play-services-location:12.0.0 do zależności pliku build.gradle aplikacji. Więcej informacji znajdziesz w sekcji Konfiguracja Usługi Google Play.

2. Aby określić com.google.android.gms.permission.ACTIVITY_RECOGNITION uprawnienia, dodaj <uses-permission>. w pliku manifestu aplikacji, jak 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 zacząć otrzymywać powiadomienia o przeniesieniu aktywności, musisz zaimplementować następujące:

• An ActivityTransitionRequest określający typ działania i przejścia.
• Wywołanie zwrotne typu PendingIntent, w którym aplikacja otrzymuje powiadomienia. Więcej informacji znajdziesz w sekcji Korzystanie z oczekującej .

Aby utworzyć ActivityTransitionRequest musisz utworzyć listę ActivityTransition obiekty reprezentujące przejście, o którym chcesz otrzymywać powiadomienia na temat witryny. An ActivityTransition zawiera te dane:

• Typ aktywności reprezentowany przez DetectedActivity zajęcia. Interfejs Migrate API obsługuje te działania:
  • IN_VEHICLE
  • ON_BICYCLE
  • RUNNING
  • STILL
  • WALKING
• Typ przejścia ACTIVITY_TRANSITION_ENTER lub ACTIVITY_TRANSITION_EXIT Aby dowiedzieć się więcej, zapoznaj się z ActivityTransition zajęcia.

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

Możesz utworzyć ActivityTransitionRequest obiektu, przekazując listę ActivityTransitions do funkcji ActivityTransitionRequest zgodnie z poniższym przykładem:

val request = ActivityTransitionRequest(transitions)

ActivityTransitionRequest request = new ActivityTransitionRequest(transitions);

Możesz zarejestrować się w celu otrzymywania aktualizacji przeniesienia aktywności, przekazując instancję ActivityTransitionRequest a obiekt PendingIntent w requestActivityTransitionUpdates() . Metoda requestActivityTransitionUpdates() zwraca błąd Task. obiekt, który można sprawdzić pod kątem powodzenia lub niepowodzenia, jak pokazano w poniższym kodzie. przykład:

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

Po zarejestrowaniu się w celu otrzymywania aktualizacji aktywności Twoja aplikacja otrzymuje powiadomienia w zarejestrowanych PendingIntent.

Przetwarzaj zdarzenia związane z przenoszeniem aktywności

Po wystąpieniu żądanej zmiany aktywności aplikacja otrzyma wywołanie zwrotne Intent. An ActivityTransitionResult można wyodrębnić obiekt z Intent, który zawiera listę ActivityTransitionEvent obiektów. Wydarzenia są uporządkowane chronologicznie. Na przykład, jeśli aplikacja żądań dotyczących IN_VEHICLE rodzaj aktywności w ACTIVITY_TRANSITION_ENTER oraz ACTIVITY_TRANSITION_EXIT przeniesie użytkowników, otrzyma wówczas obiekt ActivityTransitionEvent, rozpoczyna jazdę, a drugi po przejściu do innej czynności.

Możesz zaimplementować wywołanie zwrotne, tworząc podklasę BroadcastReceiver i implementując metodę onReceive(), która pobiera listę zdarzeń związanych z przenoszeniem aktywności. Więcej informacji: Komunikaty. Ten przykład pokazuje, aby 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....
        }
    }
}

Zarejestruj się, aby otrzymywać informacje o zmianach w przenoszeniu aktywności

Możesz się zarejestrować, aby otrzymywać informacje o zmianach w przenoszeniu aktywności, wywołując removeActivityTransitionUpdates() funkcji ActivityRecognitionClient i przekazując obiekt PendingIntent jako parametr, 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 wykorzystaniu interfejsu API rozpoznawania aktywności użytkownika, wyświetl te informacje materiały:

Próbki

Przykład pokazujący sprawdzone metody rozpoznawania aktywności użytkownika.