Rileva quando gli utenti iniziano o terminano un'attività

Potrebbe essere necessario progettare l'app per identificare quando un utente avvia o interrompe una determinata attività, ad esempio camminata, ciclismo o guida. Ad esempio, un'app per il monitoraggio delle miglia potrebbe iniziare a tracciare i chilometri quando un utente inizia a guidare oppure un'app di messaggistica potrebbe disattivare tutte le conversazioni fino a quando l'utente smette di guidare.

L'API Activity Recognition Transizione può essere utilizzata per rilevare cambiamenti nell'attività dell'utente. La tua app si abbona a una transizione per le attività che ti interessano e l'API invia una notifica alla tua app solo quando necessario. Questa pagina mostra come utilizzare l'API Activity Recognition Transizione, nota anche come API Transizione.

Configura il progetto

Per utilizzare l'API Transizione nella tua app, devi dichiarare una dipendenza dalla versione 12.0.0 o successiva dell'API Google Location and Activity Recognition e specificare l'autorizzazione com.google.android.gms.permission.ACTIVITY_RECOGNITION nel file manifest dell'app.

1. Per dichiarare una dipendenza all'API, aggiungi un riferimento al repository Maven di Google e una voce di implementazione a com.google.android.gms:play-services-location:12.0.0 alla sezione delle dipendenze del file build.gradle dell'app. Per ulteriori informazioni, consulta Configurare Google Play Services.

2. Per specificare l'autorizzazione com.google.android.gms.permission.ACTIVITY_RECOGNITION, aggiungi un elemento <uses-permission> nel file manifest dell'app, come mostrato nell'esempio seguente:

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

Registrati per ricevere aggiornamenti sulla transizione delle attività

Per iniziare a ricevere notifiche sulle transizioni delle attività, devi implementare quanto segue:

• Un oggetto ActivityTransitionRequest che specifica il tipo di attività e la transizione.
• Un callback PendingIntent in cui la tua app riceve le notifiche. Per ulteriori informazioni, consulta Utilizzo di un intent in attesa.

Per creare l'oggetto ActivityTransitionRequest, devi creare un elenco di oggetti ActivityTransition, che rappresentano la transizione per cui vuoi ricevere notifiche. Un oggetto ActivityTransition include i seguenti dati:

• Un tipo di attività, rappresentato dalla classe DetectedActivity. L'API Transizione supporta le seguenti attività:
  • IN_VEHICLE
  • ON_BICYCLE
  • RUNNING
  • STILL
  • WALKING
• Un tipo di transizione ACTIVITY_TRANSITION_ENTER o ACTIVITY_TRANSITION_EXIT. Per ulteriori informazioni, consulta la lezione ActivityTransition.

Il codice seguente mostra come creare un elenco di oggetti 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());

Puoi creare un oggetto ActivityTransitionRequest passando l'elenco di ActivityTransitions alla classe ActivityTransitionRequest, come mostrato nell'esempio seguente:

val request = ActivityTransitionRequest(transitions)

ActivityTransitionRequest request = new ActivityTransitionRequest(transitions);

Puoi registrarti per gli aggiornamenti della transizione delle attività passando l'istanza di ActivityTransitionRequest e l'oggetto PendingIntent al metodo requestActivityTransitionUpdates(). Il metodo requestActivityTransitionUpdates() restituisce un oggetto Task di cui puoi verificare l'esito positivo o negativo, come illustrato nell'esempio di codice riportato di seguito:

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

Dopo aver eseguito correttamente la registrazione per gli aggiornamenti sulla transizione delle attività, l'app riceve le notifiche nel dominio PendingIntent registrato.

Elabora gli eventi di transizione delle attività

Quando si verifica la transizione dell'attività richiesta, l'app riceve un callback Intent. Un oggetto ActivityTransitionResult può essere estratto da Intent, che include un elenco di oggetti ActivityTransitionEvent. Gli eventi vengono ordinati in ordine cronologico, ad esempio, se un'app richiede il tipo di attività IN_VEHICLE nelle transizioni di ACTIVITY_TRANSITION_ENTER e ACTIVITY_TRANSITION_EXIT, riceve un oggetto ActivityTransitionEvent quando l'utente inizia a guidare e un altro quando l'utente passa a un'altra attività.

Puoi implementare il callback creando una sottoclasse di BroadcastReceiver e implementando il metodo onReceive() per ottenere l'elenco degli eventi di transizione delle attività. Per ulteriori informazioni, consulta la sezione Trasmissioni. L'esempio seguente mostra come implementare il metodo 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....
        }
    }
}

Annulla la registrazione per gli aggiornamenti sulla transizione delle attività

Puoi annullare la registrazione per gli aggiornamenti della transizione delle attività chiamando il metodo removeActivityTransitionUpdates() di ActivityRecognitionClient e passando l'oggetto PendingIntent come parametro, come mostrato nell'esempio seguente:

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

Risorse aggiuntive

Per scoprire di più sull'utilizzo dell'API User Activity Recognition, consulta i seguenti materiali:

Samples

Esempio per dimostrare le best practice per il riconoscimento dell'attività utente.