Como encerrar o aplicativo Android programaticamente

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?

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.

getActivity().finish();
System.exit(0);

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

A melhor solução para mim.

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

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.

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.

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

}

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

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

Você pode usar finishAndRemoveTask ()da API 21

public void finishAndRemoveTask ()

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

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.

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

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

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

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

activity.moveTaskToBack(Boolean nonRoot);

public void quit() {
        int pid = android.os.Process.myPid();
        android.os.Process.killProcess(pid);
        System.exit(0);
    }

Semelhante ao @MobileMateo, mas no Kotlin

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

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!

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.

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

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.

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.

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

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.

Isso matará qualquer coisa;)

int p = android.os.Process.myPid();
android.os.Process.killProcess(p);

Tente isto

int pid = android.os.Process.myPid();
android.os.Process.killProcess(pid);

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

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>

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

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

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!

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