Como verificar se uma atividade é a última na pilha de atividades de um aplicativo?

Quero saber se o usuário retornaria à tela inicial se sair da atividade atual.

ATUALIZAÇÃO (jul de 2015):

Desde getRunningTasks () se obsoleta, de API 21, é melhor seguir raukodraug resposta ou Ed Burnette um (eu preferiria segundo).

Há possibilidade de verificar as tarefas atuais e sua pilha usando o ActivityManager .

Portanto, para determinar se uma atividade é a última:

• solicite permissões android.permission.GET_TASKS no manifesto.

• Use o seguinte código:
  

  ActivityManager mngr = (ActivityManager) getSystemService( ACTIVITY_SERVICE );
  
  List<ActivityManager.RunningTaskInfo> taskList = mngr.getRunningTasks(10);
  
  if(taskList.get(0).numActivities == 1 &&
     taskList.get(0).topActivity.getClassName().equals(this.getClass().getName())) {
      Log.i(TAG, "This is last activity in the stack");
  }

Observe que o código acima será válido apenas se você tiver uma única tarefa. Se houver a possibilidade de existir um número de tarefas para o seu aplicativo - você precisará verificar outros elementos taskList . Leia mais sobre tarefas Tarefas e Back Stack

Vou postar o comentário do @ H9kDroid como a melhor resposta aqui para pessoas que têm uma pergunta semelhante.

Você pode usar isTaskRoot () para saber se a atividade é a raiz de uma tarefa.

Eu espero que isso ajude

Espero que isso ajude os novos iniciantes. Com base nas respostas acima, que funcionam bem para mim, também estou compartilhando um trecho de código para que seja fácil de implementar.

solução: usei o isTaskRoot()que retornará true se a atividade atual for apenas atividade na sua pilha e outro que não seja também o caso em que, se tiver alguma atividade na pilha, vá para a última atividade na pilha em vez de abrir uma nova personalizada.

Na sua atividade

   @Override
    public void onBackPressed() {

        if(isTaskRoot()){
            startActivity(new Intent(currentActivityName.this,ActivityNameYouWantToOpen.class));
            // using finish() is optional, use it if you do not want to keep currentActivity in stack
            finish();
        }else{
            super.onBackPressed();
        }

    }

existe uma solução mais fácil para isso, você pode usar isTaskRoot () em sua atividade

Embora possa haver uma maneira de conseguir isso (consulte outras respostas), sugiro que você não faça isso. Os aplicativos normais do Android não precisam saber se a tela inicial está prestes a ser exibida ou não.

Se você estiver tentando salvar dados, coloque o código para salvar dados no método onPause (). Se você está tentando dar ao usuário uma maneira de mudar de idéia sobre a existência do aplicativo, você pode interceptar a tecla para cima / baixo da tecla Voltar e do método onBackPressed () e apresentá-lo com um "Você tem certeza?" pronto.

Uma maneira de acompanhar isso é incluir um marcador quando você inicia uma nova atividade e verificar se o marcador existe.

Sempre que você iniciar uma nova atividade, insira o marcador:

newIntent=new Intent(this, NextOne.class);
newIntent.putExtra(this.getPackageName()+"myself", 0);
startActivity(newIntent);

E você pode então verificar assim:

boolean islast=!getIntent().hasExtra(this.getPackageName()+"myself")

O problema com a solução da sandrstar ActivityManageré: você precisa de uma permissão para executar as tarefas dessa maneira. Eu encontrei uma maneira melhor:

getIntent().hasCategory(Intent.CATEGORY_LAUNCHER)

A Activityparte inferior da pilha deve sempre obter essa categoria por padrão, enquanto outras atividades não devem obtê-la.
Mas mesmo que isso falhe em alguns dispositivos, você pode configurá-lo ao iniciar o seu Activity:

Intent intent = new Intent(startingActivity, SomeActivityClass.class);
intent.addCategory(Intent.CATEGORY_LAUNCHER);
activity.startActivity(intent);

Criei uma classe base para todas as minhas atividades, estendendo o AppCompatActivity e que possui um contador estático:

public abstract class BasicActivity extends AppCompatActivity {
    private static int activityCounter = 0;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        ++activityCounter;
        ...
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        --activityCounter;
        if(activityCounter==0) {
            // Last instance code...
        }
    }

    public boolean isLastInstance() { return (activityCounter==1); }
}

Até agora, isso funcionou bem o suficiente; e independentemente da versão da API. É claro que exige que todas as atividades estendam essa classe base - o que elas fazem, no meu caso.

Editar: notei uma instância em que o contador cai para zero antes de o aplicativo sair completamente, ou seja, quando a orientação é alterada e apenas uma atividade é aberta. Quando a orientação muda, a atividade é fechada e outra é criada, então onDestroyedé chamada para a última atividade e, em seguida, onCreateé chamada quando a mesma atividade é criada com a orientação alterada. Esse comportamento deve ser considerado; OrientationEventListener poderia ser usado.

O Android implementa uma pilha de atividades. Sugiro que você leia aqui . Parece que tudo que você quer fazer, porém, é recuperar a atividade de vocalização: getCallingActivity(). Se a atividade atual é a primeira atividade em seu aplicativo e o aplicativo foi iniciado a partir da tela inicial, devo (presumo) retornar null.

A única coisa que faltou aqui é o clique na "tecla Home", quando ativado, você não pode detectar isso em sua atividade; portanto, é melhor controlar a pilha de atividades programaticamente com o manuseio da tecla "Back key" e a mudança para a atividade necessária ou apenas executando as etapas necessárias.

Além disso, você não pode ter certeza de que o início de sua atividade da lista "Atividade recente" pode ser detectado com a predefinição de alguns dados extras na intenção de abrir a atividade, pois ela é reutilizada nesse caso.