Como sair do aplicativo e mostrar a tela inicial?

Eu tenho um aplicativo em que, na página inicial, tenho botões para navegar pelo aplicativo.

Nessa página, tenho o botão "SAIR" que, quando clicado, leva o usuário à tela inicial do telefone onde está o ícone do aplicativo.

Como eu posso fazer isso?

O design do Android não favorece a saída de um aplicativo por opção, mas o gerencia pelo sistema operacional. Você pode abrir o aplicativo Home por sua intenção correspondente:

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

Pode ser que você possa tentar algo como isto

Suponha que em nosso aplicativo tenhamos várias atividades (digamos dez) e precisamos sair diretamente dessa atividade. O que podemos fazer é criar uma intenção e ir para a atividade raiz e definir sinalizador na intenção como

intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);

Além disso, adicione alguns extras como booleano à intenção

intent.putExtra("EXIT", true);

Em seguida, na atividade raiz, verifique o valor da booleane de acordo com a chamada finish (), na onCreate()atividade raiz

if (getIntent().getBooleanExtra("EXIT", false)) {
 finish();
}

System.exit(0);

Provavelmente é o que você está procurando. Ele fechará o aplicativo inteiro e o levará à tela inicial.

Isto funciona bem para mim.
Feche todas as atividades anteriores da seguinte maneira:

    Intent intent = new Intent(this, MainActivity.class);
    intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
    intent.putExtra("Exit me", true);
    startActivity(intent);
    finish();

Em seguida, no método MainActivity onCreate (), adicione-o para finalizar o MainActivity

    setContentView(R.layout.main_layout);

    if( getIntent().getBooleanExtra("Exit me", false)){
        finish();
        return; // add this to prevent from doing unnecessary stuffs
    }

primeiro finalize seu aplicativo usando o método finish();

e adicione as linhas abaixo no onDestroy for Removing Force

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

Se você deseja encerrar uma atividade, basta ligar finish(). No entanto, é uma prática ruim ter um botão de saída na tela.

Algumas atividades, na verdade, você não deseja abrir novamente quando o botão Voltar pressionou essa atividade da tela inicial, atividade da tela de boas-vindas e janelas de confirmação. Na verdade, você não precisa disso na pilha de atividades. você pode fazer isso usando => abrir o arquivo manifest.xml e adicionar um atributo

android: noHistory = "true"

para essas atividades.

<activity
    android:name="com.example.shoppingapp.AddNewItems"
    android:label="" 
    android:noHistory="true">
</activity>

OU

Às vezes, você deseja fechar o aplicativo inteiro pressionando o botão Voltar. Aqui, a melhor prática é abrir a janela inicial em vez de sair do aplicativo. Para isso, você precisa substituir o método onBackPressed (). geralmente esse método abre a atividade principal na pilha.

@Override
public void onBackPressed(){
Intent a = new Intent(Intent.ACTION_MAIN);
a.addCategory(Intent.CATEGORY_HOME);
a.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
startActivity(a);

}

OU

No botão Voltar pressionado, você deseja sair dessa atividade e também não deseja adicionar isso na pilha de atividades. chame o método finish () dentro do método onBackPressed (). não fechará o aplicativo inteiro. irá para a atividade anterior na pilha.

@Override
public void onBackPressed() {
  finish();
}

Não é recomendável sair do seu aplicativo Android. Veja esta pergunta para mais detalhes.

O usuário sempre pode sair do seu aplicativo pelo botão home ou na primeira atividade pelo botão back.

(Tentei respostas anteriores, mas elas carecem de alguns pontos. Por exemplo, se você não fizer uma return; atividade após o término da atividade, o código de atividade restante será executado. Também é necessário editar onCreate com retorno. Se você não executar super.onCreate () você receberá um erro de tempo de execução)

Diga que você tem MainActivitye ChildActivity.

Dentro do ChildActivity, adicione isto:

Intent intent = new Intent(ChildActivity.this, MainActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
intent.putExtra("EXIT", true);
startActivity(intent);
return true;

No onCreate da MainActivity, adicione isto:

@Override
public void onCreate(Bundle savedInstanceState) {

    mContext = getApplicationContext();

    super.onCreate(savedInstanceState);

    if (getIntent().getBooleanExtra("EXIT", false)) {
        finish();
        return;
    }
    // your current codes
    // your current codes
}

Há outra opção, usar o método FinishAffinity para fechar todas as tarefas na pilha relacionadas ao aplicativo.

Consulte: https://stackoverflow.com/a/27765687/1984636

Quando a chamada u terminar em onDestroy () dessa atividade será chamada e voltará à atividade anterior na pilha de atividades ... Então .. para exit, não chame finish ();

Aqui está o que eu fiz:

SomeActivity.java

 @Override
    public void onBackPressed() {
            Intent newIntent = new Intent(this,QuitAppActivity.class);
            newIntent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP|Intent.FLAG_ACTIVITY_CLEAR_TASK | Intent.FLAG_ACTIVITY_NEW_TASK);
            startActivity(newIntent);
            finish();
    }

QuitAppActivity.java

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

Basicamente, o que você fez é limpar todas as atividades da pilha e do lançamento QuitAppActivity, que concluirão a tarefa.

Adicione as seguintes linhas depois finish();de onDestroy():

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

Tentei sair do aplicativo usando o seguinte trecho de código: funcionou para mim. Espero que isso ajude você. eu fiz uma pequena demonstração com 2 atividades

primeira atividade

public class MainActivity extends Activity implements OnClickListener{
    private Button secondActivityBtn;
    private SharedPreferences pref;
    private SharedPreferences.Editor editer;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        secondActivityBtn=(Button) findViewById(R.id.SecondActivityBtn);
        secondActivityBtn.setOnClickListener(this);

        pref = this.getSharedPreferences("MyPrefsFile", MODE_PRIVATE);
        editer = pref.edit();

        if(pref.getInt("exitApp", 0) == 1){
            editer.putInt("exitApp", 0);
            editer.commit();
            finish();
        }
    }
    @Override
    public void onClick(View v) {
        switch (v.getId()) {
        case R.id.SecondActivityBtn:
            Intent intent= new Intent(MainActivity.this, YourAnyActivity.class);
            startActivity(intent);
            break;
        default:
            break;
        }
    }
}

sua outra atividade

public class YourAnyActivity extends Activity implements OnClickListener {
    private Button exitAppBtn;
    private SharedPreferences pref;
    private SharedPreferences.Editor editer;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_any);

        exitAppBtn = (Button) findViewById(R.id.exitAppBtn);
        exitAppBtn.setOnClickListener(this);

        pref = this.getSharedPreferences("MyPrefsFile", MODE_PRIVATE);
        editer = pref.edit();
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
        case R.id.exitAppBtn:
            Intent main_intent = new Intent(YourAnyActivity.this,
                    MainActivity.class);
            main_intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
            startActivity(main_intent);
            editer.putInt("exitApp",1);
            editer.commit();
            break;
        default:
            break;
        }
    }
}

Eu fiz isso no modo observador.

Interface do observador

public interface Observer {
public void update(Subject subject);
}

Assunto base

public class Subject {
private List<Observer> observers = new ArrayList<Observer>();

public void attach(Observer observer){
    observers.add(observer);
}

public void detach(Observer observer){
    observers.remove(observer);
}

protected void notifyObservers(){
    for(Observer observer : observers){
        observer.update(this);
    }
}
}

Assunto Criança implementa o método de saída

public class ApplicationSubject extends Subject {
public void exit(){
    notifyObservers();
}
}

MyApplication que seu aplicativo deve estender

public class MyApplication extends Application {

private static ApplicationSubject applicationSubject;

public ApplicationSubject getApplicationSubject() {
            if(applicationSubject == null) applicationSubject = new ApplicationSubject();
    return applicationSubject;
}

}

Atividade base

public abstract class BaseActivity extends Activity implements Observer {

public MyApplication app;

@Override
protected void onCreate(Bundle savedInstanceState) {
    // TODO Auto-generated method stub
    super.onCreate(savedInstanceState);
    app = (MyApplication) this.getApplication();
    app.getApplicationSubject().attach(this);
}

@Override
public void finish() {
    // TODO Auto-generated method stub
            app.getApplicationSubject().detach(this);
    super.finish();
}

/**
 * exit the app
 */
public void close() {
    app.getApplicationSubject().exit();
};

@Override
public void update(Subject subject) {
    // TODO Auto-generated method stub
    this.finish();
}

}

vamos testar

public class ATestActivity extends BaseActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
    // TODO Auto-generated method stub
    super.onCreate(savedInstanceState);
    close(); //invoke 'close'
}
}

se você quiser sair do aplicativo, coloque este código em sua função

public void yourFunction()
{
finishAffinity();   
moveTaskToBack(true);

}



//For an instance, if you want to exit an application on double click of a 
//button,then the following code can be used.
@Override
public boolean onKeyDown(int keyCode, KeyEvent event)  {
    if (keyCode == KeyEvent.KEYCODE_BACK && event.getRepeatCount() == 2) {
        // do something on back.
        From Android 16+ you can use the following:

        finishAffinity();
        moveTaskToBack(true);
    }

    return super.onKeyDown(keyCode, event);
}

100% funciona bem. este é o código para sair do aplicativo onClick (método)

    Button exit = (Button)findViewById(R.id.exitbutton);

    exit.setOnClickListener(new View.OnClickListener() {

        @Override

        public void onClick(View view) {

            finish();
            android.os.Process.killProcess(android.os.Process.myPid());
            System.exit(1);
            Toast.makeText(getApplicationContext(), "Closed Completely and Safely", Toast.LENGTH_LONG).show();

        }
    });

Você pode simplesmente adicionar os moveTaskToBack(true)botões de saída onClickedListenerpara minimizar o aplicativo.

Espero que ajude.

Talvez meu código possa hepls (Main_Activity.java):

    @Override
    protected void onDestroy() {
        super.onDestroy();
        this.finish();
        exit(0);
    }

    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event)  {
        switch(keyCode)    {
            case KeyEvent.KEYCODE_BACK:
                AlertDialog.Builder builder = new AlertDialog.Builder(this);
                builder.setTitle("My application").setMessage("Keep playing?").setIcon(R.drawable.icon);
                // Go to backgroung
                builder.setPositiveButton("OK", new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog, int which) { moveTaskToBack(true); }
                });
                // Exit from app calling protected void onDestroy()
                builder.setNegativeButton("CLOSE APPLICATION", new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog, int which) { onDestroy(); }
                });
                // Close this dialog
                builder.setNeutralButton("CANCEL", new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog, int which) { dialog.cancel(); }
                });
                AlertDialog dialog = builder.create();
                dialog.show();
                return true;
        }
        return false;
    }

Se você deseja sair do seu aplicativo. Em seguida, use esse código dentro do evento pressionado no botão. gostar:

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