Como encerrar o aplicativo Android programaticamente

322

Encontrei alguns códigos para sair de um aplicativo Android programaticamente. Ao chamar qualquer um dos seguintes códigos em onDestroy (), ele encerrará o aplicativo completamente?

  1. System.runFinalizersOnExit(true)
    (OU)
  2. android.os.Process.killProcess(android.os.Process.myPid());

Não quero executar meu aplicativo em segundo plano depois de clicar no botão sair. Por favor, sugira que eu possa usar qualquer um desses códigos para sair do meu aplicativo? Se sim, qual código posso usar? É uma boa maneira de sair do aplicativo no Android?

Vignesh
fonte
Já existem muitas postagens aqui. stackoverflow.com/search?q=how+to+exit+an+android+app
Mudassir
2
possível duplicata de Sair de um aplicativo - isso é desaprovado?
CommonsWare
use 'System.exit (0);' quando você realmente deseja sair do aplicativo. Fiz isso com um erro irrecuperável depois de mostrar uma mensagem ao usuário. Se necessário, você pode reiniciar automaticamente o aplicativo usando o AlarmManager. Veja: blog.janjonas.net/2010-12-20/…
Alguém em algum lugar

Respostas:

398

Desde a API 16, você pode usar o método finishAffinity, que parece bem próximo de fechar todas as atividades relacionadas por seu nome e descrição do Javadoc:

this.finishAffinity();

Conclua esta atividade e todas as atividades imediatamente abaixo dela na tarefa atual que possui a mesma afinidade. Isso geralmente é usado quando um aplicativo pode ser iniciado para outra tarefa (como de um ACTION_VIEW de um tipo de conteúdo que ele entende) e o usuário usa a navegação para alternar para a tarefa atual e para sua própria tarefa. Nesse caso, se o usuário tiver navegado para outras atividades do segundo aplicativo, todas elas deverão ser removidas da tarefa original como parte da troca de tarefas.

Observe que esse acabamento não permite que você entregue resultados à atividade anterior e uma exceção será lançada se você estiver tentando fazê-lo.


Desde a API 21, você pode usar um comando muito semelhante

finishAndRemoveTask();

Finaliza todas as atividades nesta tarefa e a remove da lista de tarefas recentes.

sivi
fonte
28
Definitivamente, esta é a resposta certa! Não é uma boa solução terminar um aplicativo usando System.exit(0);. Obrigado pela sua resposta! Finalmente encontrei uma solução decente.
Antonio
4
Você sabe se existe outra solução na API 14? Obrigado
Script Kitty
2
Você pode finalizar () cada atividade individualmente, ao fechar o aplicativo ou dentro do ciclo de vida da atividade.
Sivi
3
AVISO! this.finishAffinity () fecha o aplicativo removendo-o da memória, para que você não receba mensagens push e assim por diante.
Tincho825
7
Esta solução funciona 99% dos casos. No entanto, não destruirá o processo, por exemplo, Dagger não será limpo. Nesses casos raros, onde é necessário matar o processo, System.exit(0)é a única solução que funcionou para mim.
Slav
155
getActivity().finish();
System.exit(0);

esta é a melhor maneira de sair do seu aplicativo. !!!

A melhor solução para mim.

Devon
fonte
Sim, funciona muito bem! É necessário chamar isso da MainActivity para que funcione!
Mz87 #
Solução perfeita. Não há necessidade de encerrar o processo, pois o Android é o melhor para gerenciamento de memória. No entanto, isso fornece uma solução para concluir a atividade, além de sair do aplicativo para conveniência do usuário.
IAmTheSquidward
Solução perfeita realmente. Corrigido muitos problemas. Obrigado.
Superusuáriodo
26
Não acho que seja uma boa solução. Você não deve terminar seu programa usando System.exit(0);. A solução certa foi publicado por @sivi (sua resposta é acima)
Antonio
13
esta não é a solução, ele não funciona se você tiver uma pilha de atividades
user3290180
46

finishAffinity();

System.exit(0);

Se você usará apenas finishAffinity();sem que System.exit(0);seu aplicativo seja encerrado, mas a memória alocada ainda estará em uso pelo telefone, então ... se você deseja que um aplicativo seja limpo e realmente saia, use os dois.

Este é o método mais simples e funciona em qualquer lugar, saia do aplicativo de verdade, você pode ter muita atividade aberta e ainda sairá sem problemas.

exemplo em um botão, clique

public void exitAppCLICK (View view) {

    finishAffinity();
    System.exit(0);

}

ou se você quiser algo legal, por exemplo, com uma caixa de diálogo de alerta com 3 botões SIM NÃO e CANCELAR

// alertdialog for exit the app
AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(this);

// set the title of the Alert Dialog
alertDialogBuilder.setTitle("your title");

// set dialog message
alertDialogBuilder
        .setMessage("your message")
        .setCancelable(false)
        .setPositiveButton("YES"),
                new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog,
                                        int id) {
                        // what to do if YES is tapped
                        finishAffinity();
                        System.exit(0);
                    }
                })

        .setNeutralButton("CANCEL"),
                new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog,
                                        int id) {
                        // code to do on CANCEL tapped
                        dialog.cancel();
                    }
                })

        .setNegativeButton("NO"),
                new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog,
                                        int id) {
                        // code to do on NO tapped
                        dialog.cancel();
                    }
                });

AlertDialog alertDialog = alertDialogBuilder.create();

alertDialog.show();
Cristian Babarusi
fonte
3
esta é a resposta correta, eu estava procurando. obrigado
driftwood
se eu usasse o FCM ou tarefas em segundo plano no meu aplicativo, não teria nenhum problema?
Roghayeh hosseini
Era isso que eu precisava para limpar o aplicativo da memória
A1m
por favor, não use System.exit(0);Você não deve liberar essa memória, o sistema fará isso por você, se necessário. Este é o comportamento pretendido.
crgarridos 14/04
30

Por favor, pense bem se você precisa matar o aplicativo: por que não deixar o sistema operacional descobrir onde e quando liberar os recursos?

Caso contrário, se você tiver certeza absoluta, use

finish();

Como reação ao comentário de @dave appleton: a primeira coisa que você leu foi a grande combinação de perguntas / respostas @gabriel postou: O encerramento de um aplicativo é desaprovado?

Agora, assumindo que temos isso, a pergunta aqui ainda tem uma resposta, sendo que o código que você precisa se estiver fazendo alguma coisa para sair é finish(). Obviamente, você pode ter mais de uma atividade, etc, etc., mas esse não é o ponto. Vamos executar por alguns dos casos de uso

  1. Você deseja permitir que o usuário saia de tudo devido ao uso da memória e "não está sendo executado em segundo plano? Duvido. Deixe o usuário interromper determinadas atividades em segundo plano, mas deixe o sistema operacional interromper qualquer recurso desnecessário.
  2. Você deseja que um usuário não vá para a atividade anterior do seu aplicativo? Bem, configure-o para que não, ou você precisa de uma opção extra. Se na maioria das vezes as atividades anteriores = atividade anterior, o usuário não apenas pressiona para casa se quiser fazer outra coisa?
  3. Se você precisar de algum tipo de redefinição, poderá descobrir se / como / etc seu aplicativo foi encerrado e se sua atividade voltar a se concentrar, você poderá executar uma ação, mostrando uma nova tela em vez de reiniciar onde estava.

Então, no final, é claro, finish()não mata tudo, mas ainda é a ferramenta que você precisa, eu acho. Se houver um caso de uso para "matar todas as atividades", ainda não o encontrei.

Nanne
fonte
30
Chamar finish()não mata o aplicativo. finish()é usado o tempo todo: Call this when your activity is done and should be closed.é o mesmo efeito que pressionar o botão "voltar".
Tanner Perrien
Concluir irá matar a atividade. Como isso é diferente do que matar o aplauso?
Nanne
Não há nada de errado em "terminar" ou "matar" o Activity(não o Application). Por exemplo, você pode iniciar uma nova atividade para mostrar ao usuário algumas informações. Após um tempo limite ou pressionando 'OK', você pode ligar finish()para retornar à atividade de chamada.
Tanner Perrien
42
A maioria dos aplicativos Android tem mais de uma atividade.
CommonsWare
4
@Nanne - Uma tela de bloqueio é um exemplo de quando você deseja interromper todas as atividades. Suponha que você faça login em um aplicativo bancário. Após um certo período de tempo sem interação do usuário, a tela de bloqueio é iniciada. Você desejará interromper todas as atividades se alguém clicar no botão Voltar na tela de bloqueio!
Jabari #
19

Eu acho que o aplicativo deve ser morto em algum caso. Por exemplo, existe um aplicativo que pode ser usado somente após o login. A atividade de login possui dois botões, 'login' e 'cancel'. Quando você clica no botão 'cancelar', definitivamente significa 'Finalizar o aplicativo'. Ninguém quer o aplicativo vivo em segundo plano. Por isso, concordo que alguns casos precisam desligar o aplicativo.

sunghun
fonte
2
Concordo totalmente com este caso de uso. Considere também meu aplicativo seguro que deve estar disponível em um determinado local e deve fazer o melhor para fechar se o usuário não estiver nesse local. O que eu faço?
Sydwell #
18

Crie um ExitActivitye declare-o no manifesto. E ligue ExitActivity.exit(context)para sair do aplicativo.

public class ExitActivity extends AppCompatActivity {

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

    public static void exit(Context context) {
        Intent intent = new Intent(context, ExitActivity.class);
        intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK);
        context.startActivity(intent);
    }

}
vivek
fonte
Esta é a resposta mais votada, no entanto, é um hack. A conclusão da chamada no onCreate ficará com defeito na maioria dos dispositivos, se não em todos.
DoruChidean
Hmm, é um truque, mas não uma falha. A primeira saída () que você chamará, ela ocorre no topo de todas as atividades, com a parte superior e as tarefas claras e depois termina sozinha. aqui você sai.
vivek
1
Lembre-se de declarar esta classe em seu manifesto. +1 para o truque inteligente.
Taslim Oseni
Isso funcionou! votado
TuanDPH 15/06
17

Não há nenhum aplicativo saindo no android , SampleActivity.this.finish (); finalizará a atividade atual.

Quando você muda de uma atividade para outra, continue com a anterior

Intent homeintent = new Intent(SampleActivity.this,SecondActivity.class);
startActivity(homeintent);
SampleActivity.this.finish();
san
fonte
13

Primeiro de tudo, essa abordagem requer min Api 16.

Vou dividir esta solução em 3 partes para resolver esse problema mais amplamente.

1. Se você deseja sair do aplicativo em uma Atividade, use este trecho de código:

if(Build.VERSION.SDK_INT>=16 && Build.VERSION.SDK_INT<21){
    finishAffinity();
} else if(Build.VERSION.SDK_INT>=21){
    finishAndRemoveTask();
}

2. Se você deseja sair do aplicativo em uma classe não Activity que tenha acesso a Activity, use este trecho de código:

if(Build.VERSION.SDK_INT>=16 && Build.VERSION.SDK_INT<21){
    getActivity().finishAffinity();
} else if(Build.VERSION.SDK_INT>=21){
    getActivity().finishAndRemoveTask();
}

3. Se você deseja sair do aplicativo em uma classe que não seja Activity e não pode acessar atividades como Service, eu recomendo que você use BroadcastReceiver. Você pode adicionar essa abordagem a todas as suas atividades no seu projeto.

Crie variáveis ​​de instância LocalBroadcastManager e BroadcastReceiver. Você pode substituir getPackageName () + ". Closeapp" se desejar.

LocalBroadcastManager mLocalBroadcastManager;
BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() {
    @Override
    public void onReceive(Context context, Intent intent) {
        if(intent.getAction().equals(getPackageName()+".closeapp")){
            if(Build.VERSION.SDK_INT>=16 && Build.VERSION.SDK_INT<21){
                finishAffinity();
            } else if(Build.VERSION.SDK_INT>=21){
                finishAndRemoveTask();
            }
        }
    }
};

Adicione-os ao método de atividade onCreate ().

mLocalBroadcastManager = LocalBroadcastManager.getInstance(this);
IntentFilter mIntentFilter = new IntentFilter();
mIntentFilter.addAction(getPackageName()+".closeapp");
mLocalBroadcastManager.registerReceiver(mBroadcastReceiver, mIntentFilter);

Além disso, não se esqueça de chamar unregister receiver no método de atividade onDestroy ()

mLocalBroadcastManager.unregisterReceiver(mBroadcastReceiver);

Para sair do aplicativo, você deve enviar a transmissão usando LocalBroadcastManager, que eu uso na minha classe PlayService, que estende o Serviço.

LocalBroadcastManager localBroadcastManager = LocalBroadcastManager.getInstance(PlayService.this);
localBroadcastManager.sendBroadcast(new Intent(getPackageName() + ".closeapp"));
twenk11k
fonte
10

Você pode usar finishAndRemoveTask ()da API 21

public void finishAndRemoveTask ()

Finaliza todas as atividades nesta tarefa e a remove da lista de tarefas recentes.

Vins
fonte
8

Depende de quão rápido você deseja fechar seu aplicativo.

Uma maneira segura de fechar seu aplicativo é finishAffinity ();

Ele fecha o aplicativo depois que todos os processos terminam o processamento. Isso pode levar algum tempo. Se você fechar o aplicativo dessa maneira e reiniciá-lo após um curto período de tempo, é possível que o novo aplicativo seja executado no mesmo processo. Com todos os processos não concluídos e objetos singleton do aplicativo antigo.

Se você quiser ter certeza de que seu aplicativo está fechado completamente, use System.exit (0);

Isso fechará seu aplicativo imediatamente. Mas é possível que você danifique os arquivos que seu aplicativo abriu ou que uma edição nas preferências compartilhadas não termine. Portanto, use isso com cuidado.

Se você usar o watchdog em combinação com uma tarefa de longa execução, poderá ver as influências dos diferentes métodos.

new ANRWatchDog(2000).setANRListener(new ANRWatchDog.ANRListener() {
    public void onAppNotResponding(ANRError error) {
        MainActivity.this.finishAffinity();
        System.exit(0);
    }
}).start();
for(int i = 0; i < 10; ++i){
    --i;
}

Isso mata seu aplicativo após 2 segundos sem exibir uma caixa de diálogo ANR ou algo assim. Se você remover System.exit (0) , executar esse código e reiniciar o aplicativo depois que ele for fechado, ocorrerá um comportamento estranho, porque o loop infinito ainda está em execução.

user3424426
fonte
8

É melhor usar finish()se você estiver dentro Activityou getActivity().finish()se estiver dentro Fragment.

Se você deseja sair do aplicativo completamente, use:

getActivity().finish();
System.exit(0);
Farruh Habibullaev
fonte
6

Maneira fácil e simples de sair do aplicativo

Intent homeIntent = new Intent(Intent.ACTION_MAIN);
homeIntent.addCategory(Intent.CATEGORY_HOME);
homeIntent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
startActivity(homeIntent);
Hassnain Jamil
fonte
Isso apenas traz a tela inicial ou mata o aplicativo?
Rpattabi 19/02/19
6

Queremos um código que seja robusto e simples. Esta solução funciona em dispositivos antigos e dispositivos mais recentes.

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
        getActivity().finishAffinity();
    } else{
        getActivity().finish();
        System.exit( 0 );
    }
MobileMateo
fonte
5

Eu acho que o que você está procurando é isso

activity.moveTaskToBack(Boolean nonRoot);
Ciprian
fonte
5

Semelhante ao @MobileMateo, mas no Kotlin

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
    this.finishAffinity()
} else{
    this.finish()
    System.exit(0)
}
Jerry Chong
fonte
4

Não tenho certeza se isso é desaprovado ou não, mas é assim que eu faço ...

Etapa 1 - Normalmente, tenho uma classe que contém métodos e variáveis ​​que desejo acessar globalmente. Neste exemplo, chamarei de classe "App". Crie uma variável estática Activity dentro da classe para cada atividade que seu aplicativo tiver. Em seguida, crie um método estático chamado "close" que executará o finish()método em cada uma dessas variáveis ​​de Atividade se elas NÃO forem nulas . Se você tem uma atividade principal / principal, feche-a por último:

public class App
{
    ////////////////////////////////////////////////////////////////
    // INSTANTIATED ACTIVITY VARIABLES
    ////////////////////////////////////////////////////////////////

        public static Activity activity1;
        public static Activity activity2;
        public static Activity activity3;

    ////////////////////////////////////////////////////////////////
    // CLOSE APP METHOD
    ////////////////////////////////////////////////////////////////

        public static void close()
        {
            if (App.activity3 != null) {App.activity3.finish();}
            if (App.activity2 != null) {App.activity2.finish();}
            if (App.activity1 != null) {App.activity1.finish();}
        }
}

Etapa 2 - em cada uma de suas atividades, substitua os métodos onStart()e onDestroy(). Em onStart(), defina a variável estática na sua classe App como " this". Em onDestroy(), defina-o igual a null. Por exemplo, na classe "Activity1":

@Override
public void onStart()
{
    // RUN SUPER | REGISTER ACTIVITY AS INSTANTIATED IN APP CLASS

        super.onStart();
        App.activity1 = this;
}

@Override
public void onDestroy()
{
    // RUN SUPER | REGISTER ACTIVITY AS NULL IN APP CLASS

        super.onDestroy();
        App.activity1 = null;
}

Etapa 3 - Quando você deseja fechar seu aplicativo, basta ligar App.close()de qualquer lugar. Todas as atividades instanciadas serão fechadas! Como você está apenas encerrando atividades e não matando o aplicativo em si (como nos exemplos), o Android é livre para assumir a partir daí e fazer a limpeza necessária.

Mais uma vez, não sei se isso seria desaprovado por qualquer motivo. Nesse caso, eu adoraria ler comentários sobre o porquê e como pode ser melhorado!

Jabari
fonte
Interessante, eu também estaria interessado no que outros desenvolvedores experientes do Android pensavam disso.
Rudi Kershaw
4
Ao manter uma referência à sua atividade, você está realmente perdendo memória! Veja isso para uma discussão aprofundada.
21814 Managarm
@Managarm A premissa por trás dessa postagem é que a variável estática permanecerá mesmo após o processo (neste caso, a Atividade) ter sido destruído. Se a limpeza adequada da casa for feita, não é um problema ... portanto, a razão pela qual anulo a referência no método onDestroy () da atividade.
Jabari #
@Jabari Ah, eu perdi a parte onDestroy. Nesse caso, não deve ser um problema, embora não seja uma prática recomendada.
Managarm
1
trabalhou sem nenhum problema. Para api>=16uso finishAffinity(), use este método.
274166 Ninguém
4

Sair de um aplicativo é mal visto? . Acesse este link. Responde a sua pergunta. O sistema faz o trabalho de matar um aplicativo.

Suponha que você tenha duas atividades A e B. Você navega de A a B. Quando você clica no botão Voltar, sua atividade B é ativada do backstack e destruída. Atividade anterior na atividade de pilha inversa A é focada.

Você deve deixar para o sistema decidir quando matar o aplicativo.

vazio público finish()

Chame isso quando sua atividade estiver concluída e deve ser fechada.

Suponha que você tenha muitas atividades. você pode usar a barra de ação. Ao clicar no ícone inicial, navegue até a MainActivity do seu aplicativo. No MainActivity, clique no botão Voltar para sair do aplicativo.

Raghunandan
fonte
3

Para sair do aplicativo, você pode usar o seguinte:

getActivity().finish();
Process.killProcess(Process.myPid());
System.exit(1);

Também para interromper os serviços, chame o seguinte método:

private void stopServices() {        
    final ActivityManager activityManager = SystemServices.getActivityManager(context);
    final List<ActivityManager.RunningServiceInfo> runningServices = activityManager.getRunningServices(Integer.MAX_VALUE);
    final int pid = Process.myPid();
    for (ActivityManager.RunningServiceInfo serviceInfo : runningServices) {
        if (serviceInfo.pid == pid && !SenderService.class.getName().equals(serviceInfo.service.getClassName())) {
            try {
                final Intent intent = new Intent();
                intent.setComponent(serviceInfo.service);
                context.stopService(intent);
            } catch (SecurityException e) { 
                 // handle exception
            }
        }
    }
}
Amir Rezazadeh
fonte
2

Isso pode ser muito tarde e também de acordo com as diretrizes de que você não deve lidar sozinho com o processo do ciclo de vida (como o SO faz isso por você). Uma sugestão seria que você registrasse um receptor de transmissão em todas as suas atividades com " finish()" nas respectivas onReceive() e sempre que desejar sair, você pode simplesmente passar uma intenção indicando que todas as atividades devem ser encerradas ..... Embora tenha certeza de que você " cancele o registro "do receptor em seus onDestroy()métodos.

Aalok Sharma
fonte
1

Não é uma boa decisão, porque é contra os princípios de processamento de aplicativos do Android. O Android não mata nenhum processo, a menos que seja absolutamente inevitável. Isso ajuda os aplicativos a iniciarem mais rapidamente, porque eles sempre são mantidos na memória. Portanto, você precisa de um motivo muito especial para interromper o processo do seu aplicativo.

Egor
fonte
4
sair de um aplicativo requer realmente matar o aplicativo. por isso não deve ser uma forma de garantir a aplicação matou depois de assinar fora
anonim
1

A solução correta e exata para sair do aplicativo ao clicar no botão está usando o código abaixo:

// Botão On pressionado Voltar evento

public void onBackPressed()
{ 
   moveTaskToBack(true);
   finish();
}
Pir Fahim Shah
fonte
Esse é o componente atual do Android (por exemplo, atividade), não o aplicativo inteiro .
Laogeodritt 15/07
Isso só enviará o aplicativo em segundo plano #
Kumar Gaurav 29/10
1

Se você estiver usando o Kotlin, a maneira correta de sair do aplicativo e a alternativa System.exit()é um método interno

exitProcess(0)

Veja a documentação .

Número 0como parâmetro significa que a saída é pretendida e nenhum erro ocorreu.

Micer
fonte
0

Isso matará qualquer coisa;)

int p = android.os.Process.myPid();
android.os.Process.killProcess(p);
D.Snap
fonte
0

Tente isto

int pid = android.os.Process.myPid();
android.os.Process.killProcess(pid);
Ahmer Afzal
fonte
0

A maneira mais fácil de encerrar um aplicativo de uma atividade, sem quebrar a lógica do Android e sem adicionar mais código às atividades existentes e passar extras, é a seguinte:

public static void quitApplication (Activity currentActivity) {
    Intent intent = new Intent (currentActivity, QuitApplicationActivity.class);
    intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK | Intent.FLAG_ACTIVITY_CLEAR_TOP);

    currentActivity.startActivity (intent);
    currentActivity.finish ();
}

o QuitApplicationActivityser:

public class QuitApplicationActivity extends AppCompatActivity {

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

        finish ();
    }
}

fonte
0

A resposta da @Sivi fecha o aplicativo. Porém, no retorno, se você tiver algumas atividades filho, outra atividade inacabada poderá ser aberta. Eu adicionei noHistory:trueminhas atividades para que o aplicativo de retorno comece a partir da MainActivity.

<activity 
      android:name=".MainActivity"
      android:noHistory="true">
</activity>
Saeed Vrz
fonte
0

Apenas para adicionar um à lista de métodos brutais de encerramento de um aplicativo:

Process.sendSignal(Process.myPid(), Process.SIGNAL_KILL);

Daniel F
fonte
Process.killProcess(Process.myPid())faz o mesmo, mas é mais curto
ivan8m8
-1

você pode encerrar seus aplicativos completos. portanto

Intent intent = getBaseContext().getPackageManager()
             .getLaunchIntentForPackage(getBaseContext().getPackageName());
intent .addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
startActivity(intent);

funcionará 100%. Boa sorte!

omor
fonte
1
Não parece uma resposta para esta pergunta!
Al-Mothafar
-4

Basta usar terminar () na tecla Voltar, pressionar emKeypressed ()

khushal rasali
fonte
4
finish () fechará uma atividade, mas certamente não fechará o aplicativo inteiro com certeza.
2Dee