Como sair de um aplicativo Android programaticamente?

Tenho certeza de que essa pergunta foi feita várias vezes porque li algumas. Meu cliente quer que eu coloque um botão em seu aplicativo onde os usuários possam clicar e sair. Eu li isso e descobri que ligar finish()é o suficiente. Mas terminar é apenas fechar a atividade de corrida atual, certo? Tenho muitas atividades, portanto, neste caso, tenho que passar por cada instância de atividade e concluí-las ou transformar todas as atividades no padrão Singleton.

Também descobri Activity.moveTaskToBack(true)que você pode acessar a tela inicial. OK, isso não é o fechamento, mas o segundo plano do processo. Então, isso é eficaz?

Qual método devo usar para fechar o aplicativo completamente? Qualquer um dos métodos acima descritos ou qualquer outro método / outro uso dos métodos acima?

Na verdade, todos estão procurando fechar o aplicativo em um evento onclick, onde quer que haja atividade ....

Então rapazes amigos tentam este código. Coloque este código no evento onclick

Intent homeIntent = new Intent(Intent.ACTION_MAIN);
    homeIntent.addCategory( Intent.CATEGORY_HOME );
    homeIntent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);  
    startActivity(homeIntent); 

O método finishAffinity, lançado na API 16, fecha todas as atividades em andamento e fecha o aplicativo:

this.finishAffinity();

Conclua esta atividade, bem como todas as atividades imediatamente abaixo dela na tarefa atual que tenham a mesma afinidade. Isso normalmente é usado quando um aplicativo pode ser iniciado em outra tarefa (como de um ACTION_VIEW de um tipo de conteúdo que ele entende) e o usuário usou a navegação para cima para sair da tarefa atual e entrar em sua própria tarefa. Nesse caso, se o usuário navegou para baixo em qualquer outra atividade do segundo aplicativo, todas elas devem ser removidas da tarefa original como parte da alternância de tarefas.

Observe que esse acabamento não permite que você forneça resultados para a atividade anterior e uma exceção será lançada se você estiver tentando fazer isso.

Desde a API 21, você pode usar:

finishAndRemoveTask();

Conclui todas as atividades desta tarefa e as remove da lista de tarefas recentes.

Alternativas:

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

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

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

Intent i = new Intent(context, LoginActivity.class);
i.putExtra(EXTRA_EXIT, true);
i.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
i.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
i.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK);
context.startActivity(i);

Fonte: Como sair do aplicativo Android de maneira programática

Espero que ajude! Boa sorte!

Você pode chamar System.exit (); para sair de todas as atividades.

    submit=(Button)findViewById(R.id.submit);

            submit.setOnClickListener(new OnClickListener() {

                @Override
                public void onClick(View arg0) {
android.os.Process.killProcess(android.os.Process.myPid());
                    System.exit(1);

                }
            });

Se você deseja sair do seu aplicativo, use este código dentro do evento de botão pressionado:

public void onBackPressed() {
  moveTaskToBack(true);
  android.os.Process.killProcess(android.os.Process.myPid());
  System.exit(1);
}

 @Override
    public void onBackPressed() {
        AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(this);
        alertDialogBuilder.setTitle("Exit Application?");
        alertDialogBuilder
                .setMessage("Click yes to exit!")
                .setCancelable(false)
                .setPositiveButton("Yes",
                        new DialogInterface.OnClickListener() {
                            public void onClick(DialogInterface dialog, int id) {
                                moveTaskToBack(true);
                                android.os.Process.killProcess(android.os.Process.myPid());
                                System.exit(1);
                            }
                        })

                .setNegativeButton("No", new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog, int id) {

                        dialog.cancel();
                    }
                });

        AlertDialog alertDialog = alertDialogBuilder.create();
        alertDialog.show();
    }

É muito fácil. UsarSystem.exit(0);

Na verdade, existem duas situações possíveis:

1. Você pode querer sair da atividade
2. Ou você deseja sair do aplicativo

Você pode sair da atividade usando o seguinte código:

var intent = new Intent(Intent.ActionMain);
intent.AddCategory(Intent.CategoryHome);
intent.SetFlags(ActivityFlags.NewTask);
startActivity(intent);
finish();

Mas isso não eliminará as atividades subjacentes no mesmo aplicativo. Isso apenas minimizará o aplicativo.

Se você deseja sair do aplicativo, use o seguinte código para encerrar o processo:

android.os.Process.killProcess(android.os.Process.myPid()); 

para desenvolvimento mono, use

process.KillProcess(Process.MyPid());

E se this.finishAffinity()

Dos documentos,

Conclua esta atividade, bem como todas as atividades imediatamente abaixo dela na tarefa atual que tenham a mesma afinidade. Isso normalmente é usado quando um aplicativo pode ser iniciado em outra tarefa (como de um ACTION_VIEW de um tipo de conteúdo que ele entende) e o usuário usou a navegação para cima para sair da tarefa atual e entrar em sua própria tarefa. Nesse caso, se o usuário navegou para baixo em qualquer outra atividade do segundo aplicativo, todas elas devem ser removidas da tarefa original como parte da alternância de tarefas. Observe que esse acabamento não permite que você forneça resultados para a atividade anterior e uma exceção será lançada se você estiver tentando fazer isso.

android.os.Process.killProcess(android.os.Process.myPid());

isso limpará a tarefa (pilha de atividades) e iniciará uma nova tarefa

Intent intent = new Intent(Intent.ACTION_MAIN);
intent.addCategory(Intent.CATEGORY_HOME);
intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK);
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
startActivity(intent);
System.exit(1);

 @Override
    public void onBackPressed() {
        Intent homeIntent = new Intent(Intent.ACTION_MAIN);
        homeIntent.addCategory( Intent.CATEGORY_HOME );
        homeIntent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
        startActivity(homeIntent);
    }

coloque este em seu onClic:

moveTaskToBack(true);
    finish()

Experimente isso em uma chamada. Às vezes, eu o uso no onClick de um botão.

Intent intent = new Intent(Intent.ACTION_MAIN);
intent.addCategory(Intent.CATEGORY_HOME);
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
startActivity(intent);

Em vez de fechar seu aplicativo, abre o painel de controle para que pareça que seu aplicativo está fechado.

leia esta pergunta para mais clareza android - código do aplicativo de saída

Use this.finishAffinity (); nesse botão em vez de terminar (); Se não funcionar, você também pode tentar adicionar android: noHistory = "true" em seu manifesto e, em seguida, terminar sua atividade usando terminar (); ou terminarAffinity ();

Espero que ajude....:)

Conquistando no Xamarin.Android:

    public override void OnBackPressed()
    {
        MoveTaskToBack(true);
        Process.KillProcess(Process.MyPid());
        Environment.Exit(1);
    }

Basta chamar essas duas funções

 finish();
 moveTaskToBack(true);

Intent homeIntent = new Intent(Intent.ACTION_MAIN);
homeIntent.addCategory( Intent.CATEGORY_HOME );
homeIntent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
startActivity(homeIntent);
System.exit(1);

Use este código, é muito útil e você pode sair de todas as atividades.

atividade fantasma chamada com singletop e finish () em onCreate deve resolver o problema

Funciona usando apenas moveTaskToBack(true);

Em vez de System.exit (1) Basta usar System.exit (0)

Se alguém ainda está se perguntando, para Xamarin.Android (no meu caso também Monogame rodando nele) o comando FinishAndRemoveTask()on Activityfaz o trabalho muito bem!

no fragmento

getActivity (). finishAndRemoveTask ();

na atividade

terminarAndRemoveTask ();

apenas use o código em seu backpress

                    Intent startMain = new Intent(Intent.ACTION_MAIN);
                    startMain.addCategory(Intent.CATEGORY_HOME);
                    startMain.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                    startActivity(startMain);

Se você estiver usando EventBus (ou realmente qualquer outra biblioteca pub / sub) em seu aplicativo para se comunicar entre as atividades, você pode enviar a eles um evento explícito:

final public class KillItWithFireEvent
{
    public KillItWithFireEvent() {}

    public static void send()
    {
        EventBus.getDefault().post(new KillItWithFireEvent());
    }
}

A única desvantagem disso é que você precisa que todas as atividades para ouvir este evento sejam próprias finish(). Para isso, você pode criar facilmente classes de atividades de shim por meio de herança, que apenas ouvem esse evento e permitem que as subclasses implementem todo o resto, depois certifique-se de que todas as suas atividades sejam herdadas dessa camada extra. Os ouvintes de morte podem até adicionar alguma funcionalidade extra por meio de substituições, como evitar a morte em certas situações específicas.

Basta executar as duas linhas abaixo quando quiser sair do aplicativo

android.os.Process.killProcess(android.os.Process.myPid());
System.exit(1);

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

trabalhou para mim

Apenas chame isso de:

finishAffinity();

Ligue este método ao seu botão sair / sair

public void quitGame(View view) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            finishAndRemoveTask();
        } else {
            finish();
        }
    }

Se você usar terminar e sair, seu aplicativo fechará completamente

terminar();

System.exit (0);