Rileva quando gli utenti iniziano o terminano un'attività

Potrebbe essere necessario progettare l'app per identificare quando un utente avvia o interrompe l'attività una determinata attività, come camminare, andare in bicicletta o guidare. Ad esempio, un un'app di monitoraggio del chilometraggio potrebbe iniziare a monitorare i chilometri quando un utente inizia a guidare o dell'app di messaggistica potrebbe disattivare tutte le conversazioni fino a quando l'utente non smette di guidare.

L'API di transizione del riconoscimento attività può essere utilizzata per rilevare le modifiche nella l'attività dell'utente. La tua app effettua l'iscrizione a una transizione nelle attività di interesse e l'API invia una notifica all'app solo quando è necessario. In questa pagina viene illustrato come utilizzare API Activity Recognition Transizione, chiamata anche API Transizione in breve.

Configura il progetto

Per utilizzare l'API Transizione nella tua app, devi dichiarare una dipendenza al Versione dell'API 12.0.0 o versioni successive dell'API Google Location and Activity Recognition e specifica l'autorizzazione com.google.android.gms.permission.ACTIVITY_RECOGNITION nel file manifest dell'app.

1. Per dichiarare una dipendenza dall'API, aggiungi un riferimento agli sviluppatori Google repository e aggiungere una voce di implementazione com.google.android.gms:play-services-location:12.0.0 alle dipendenze del file build.gradle dell'app. Per ulteriori informazioni, vedi Configurazione Google Play Services.

2. Per specificare com.google.android.gms.permission.ACTIVITY_RECOGNITION , aggiungi un'etichetta <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 sulle transizioni delle attività

Per iniziare a ricevere notifiche sulle transizioni delle attività, devi implementare le seguenti:

• Un ActivityTransitionRequest che specifica il tipo di attività e la transizione.
• Un callback PendingIntent quando la tua app riceve notifiche. Per ulteriori informazioni, consulta la sezione Utilizzo di un account intent.

Per creare il ActivityTransitionRequest occorre creare un elenco ActivityTransition che rappresentano la transizione a cui vuoi ricevere notifiche. informazioni. Un ActivityTransition include i seguenti dati:

• Un tipo di attività, rappresentato dal 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 ActivityTransition .

Il codice seguente mostra come creare un elenco di ActivityTransition oggetti:

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 nuovo ActivityTransitionRequest passando l'elenco di ActivityTransitions all'oggetto Classe ActivityTransitionRequest, come mostrato nell'esempio seguente:

val request = ActivityTransitionRequest(transitions)

ActivityTransitionRequest request = new ActivityTransitionRequest(transitions);

Puoi registrarti per gli aggiornamenti delle transizioni delle attività passando la tua istanza di ActivityTransitionRequest e l'oggetto PendingIntent requestActivityTransitionUpdates() . Il metodo requestActivityTransitionUpdates() restituisce un Task che puoi verificare se l'esito è positivo o negativo, come illustrato nel codice seguente esempio:

// 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 esserti registrato per ricevere gli aggiornamenti sulle transizioni delle attività, la tua app riceve notifiche nell'account PendingIntent registrato.

Eventi di transizione delle attività dei processi

Quando si verifica la transizione dell'attività richiesta, la tua app viene richiamata.Intent Un ActivityTransitionResult può essere estratto da Intent, che include un elenco di ActivityTransitionEvent di oggetti strutturati. Gli eventi sono in ordine cronologico, ad esempio se un'app delle richieste IN_VEHICLE tipo di attività nella ACTIVITY_TRANSITION_ENTER e ACTIVITY_TRANSITION_EXIT transizioni, riceve un oggetto ActivityTransitionEvent quando l'utente inizia a guidare e un'altra quando l'utente passa a un'altra attività.

Puoi implementare il callback creando una sottoclasse BroadcastReceiver e implementando il metodo onReceive() per ottenere l'elenco di eventi di transizione delle attività. Per ulteriori informazioni, vedi Annunci. L'esempio seguente mostra come per 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 ricevere aggiornamenti sulle transizioni delle attività

Puoi annullare la registrazione per gli aggiornamenti sulle transizioni delle attività chiamando il removeActivityTransitionUpdates() del metodo ActivityRecognitionClient e passare 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 di riconoscimento dell'attività utente, consulta quanto segue materiali:

Campioni

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