O segundo Visualização do Desenvolvedor do Android 11 já está disponível, teste e compartilhe seu feedback.

Detectar quando usuários iniciam ou encerram uma atividade

Pode ser necessário projetar seu app para identificar quando um usuário inicia ou interrompe uma atividade específica, como caminhar, andar de bicicleta ou dirigir. Por exemplo, um app de rastreamento de quilometragem pode começar a rastrear quilômetros quando um usuário começar a dirigir, ou um app de mensagens pode ignorar todas as conversas até que ele pare de dirigir.

A API Activity Recognition Transition pode ser usada para detectar mudanças na atividade do usuário. Seu app assina uma transição nas atividades de interesse, e a API notifica seu app somente quando necessário. Esta página mostra como usar a API Activity Recognition Transition, também chamada de API Transition.

Configurar seu projeto

Para usar a API Activity Recognition Transition, você precisa declarar uma dependência para a API Google Location and Activity Recognition versão 12.0.0 ou posterior e especificar a permissão com.google.android.gms.permission.ACTIVITY_RECOGNITION no manifesto do aplicativo.

  1. Para declarar uma dependência à API, adicione uma referência ao repositório maven do Google e adicione uma entrada de implementação para com.google.android.gms:play-services-location:12.0.0 à seção de dependências do arquivo build.gradle do seu app. Para mais informações, consulte Configurar o Google Play Services.
  2. Para especificar a permissão com.google.android.gms.permission.ACTIVITY_RECOGNITION, adicione um elemento <uses-permission> no manifesto do aplicativo, conforme mostrado no exemplo a seguir:

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

Inscrever-se para atualizações de transição de atividades

Para começar a receber notificações sobre transições de atividade, implemente o seguinte:

Para criar o objeto ActivityTransitionRequest, crie uma lista de objetos ActivityTransition que representa a transição sobre a qual você quer receber notificações. Um objeto ActivityTransition inclui os seguintes dados:

O código a seguir mostra como criar uma lista de objetos 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());
    

Você pode criar um objeto ActivityTransitionRequest passando a lista de ActivityTransitions para a classe ActivityTransitionRequest, como mostrado no exemplo a seguir:

Kotlin

    val request = ActivityTransitionRequest(transitions)
    

Java

    ActivityTransitionRequest request = new ActivityTransitionRequest(transitions);
    

Você pode se inscrever para atualizações de transição de atividades passando sua instância de ActivityTransitionRequest e seu objeto PendingIntent para o método requestActivityTransitionUpdates(). O método requestActivityTransitionUpdates() retorna um objeto Task que você pode verificar quanto a sucesso ou falha, como mostrado no exemplo de código a seguir:

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

Depois de se inscrever para receber atualizações de transição de atividades, seu app recebe notificações no PendingIntent registrado.

Eventos de transição da atividade do processo

Quando a transição da atividade solicitada ocorre, seu app recebe um callback Intent. Um objeto ActivityTransitionResult pode ser extraído do Intent, que inclui uma lista de objetos ActivityTransitionEvent. Os eventos são ordenados em ordem cronológica, por exemplo, se um app solicitar o tipo de atividade IN_VEHICLE nas transições ACTIVITY_TRANSITION_ENTER e ACTIVITY_TRANSITION_EXIT, ele receberá um ActivityTransitionEvent quando o usuário começar a dirigir, e outro quando o usuário fizer a transição para qualquer outra atividade.

Você pode implementar o callback criando uma subclasse de BroadcastReceiver e implementando o método onReceive() para acessar a lista de eventos de transição de atividade. Para mais informações, consulte Transmissões. O exemplo a seguir mostra como implementar o método 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....
            }
        }
    }
    

Cancelar o registro das atualizações de transição de atividades

É possível cancelar o registro de atualizações de transição de atividade chamando o método removeActivityTransitionUpdates() do ActivityRecognitionClient e passando o objeto PendingIntent como um parâmetro, como mostrado no exemplo a seguir:

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