Como sair do aplicativo e mostrar a tela inicial?

196

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?

poojan9118
fonte

Respostas:

327

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);
ognian
fonte
25
Você pode até usar .. "moveTaskToBack (true);"
precisa saber é o seguinte
17
irá alocar todos os recursos? Porque quando saio do aplicativo dessa maneira e depois de algum tempo clico no ícone do aplicativo novamente. Começa de onde eu o deixei. Isso significa que o aplicativo ainda estava sendo executado em segundo plano.
Adil Malik
12
Activity.finish ();
Hb0
11
Isso mantém seu aplicativo em segundo plano, para que ele não saia do aplicativo.
Herman Schoenfeld 24/10
3
Essa resposta apenas fará com que a tela inicial apareça e não saia / feche o aplicativo completamente como o OP deseja.
Basher51
74

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();
}
Kartik Domadiya
fonte
1
Apenas não faça nada no onCreate para chamar o acabamento.
imcaptor
2
No meu caso, eu tive que substituir onNewIntenttambém. Porque o intnet.getExtras () continuou sendo nulo.
Zznq 03/10
E este método irá reiniciar o seu em RootActivityvez de retomar a partir da pilha. Verifique aqui para superar esse stackoverflow.com/a/26258455/609782
Darpan 8/04
29
System.exit(0);

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

Ndupza
fonte
1
Isso deveria ser uma saída em minúscula?
28412 Carol #
1
deve ser System.exit (0). Mas não é muito útil de qualquer maneira.
Superarts.org
7
System.exit (0) não deve ser usado conforme recomendado pela equipe principal do Android.
Dinesh Venkata
2
Penso que esta é a melhor abordagem para circunstâncias excepcionais. Digamos que um aplicativo precise de internet e a conexão divida algumas atividades no aplicativo. Uma caixa de diálogo de alerta pode ser exibida (sem botões). O botão Voltar precisa sair de todo o aplicativo, pois a reentrada exige login / inicialização novamente. System.exit é a única coisa que funciona razoavelmente que eu encontrei. Não tenho certeza sobre o comentário @ user1699548.
Herman Schoenfeld
1
Isso matará todos os serviços relacionados a esse aplicativo também?
bsara
25

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
    }
Lazy Ninja
fonte
Isso não funciona para mim. Deixa meu aplicativo sem nada visível, mas ainda funciona de alguma forma. Eu posso ver tópicos pendurados e aguardando no depurador que nunca fará nada.
precisa saber é o seguinte
23

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

fonte
3
Nunca usar isso, porque ele recebe nenhuma chance de recursos livres
Jacky
1
-1 porque onDestroy é executado sempre que você sai da atividade, não apenas quando a tecla Voltar é pressionada.
Hamzeh Soboh 22/09
5
@ Jacky: e como matar o processo não libera nenhum recurso do sistema?
Herman Schoenfeld
1
Por que é o super.onDestroy()depois do killProcess()? essa linha seria alcançada?
shoosh 19/07/19
Isso também não mata todos os seus serviços?
Irshu 4/17/17
20

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

cristão
fonte
2
Estou usando-o para "Você precisa atualizar este aplicativo para a versão mais recente" e não quero que eles continuem usando. Ainda é uma prática ruim ...?
beetree
@beetree Sim. Como qualquer prática ruim, há casos em que essa é sua única opção, e você a usa porque tentar fazer outra coisa seria absurdo. O motivo de ser uma má prática , em oposição à sintaxe ilegal , é que ela está disponível para esses poucos casos, mas você deve tentar o seu melhor para encontrar uma maneira melhor de fazê-lo. No seu caso, não há um.
Fund Monica's Lawsuit
17

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

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.

Janusz
fonte
3
@janusz: pressionar o botão casa nunca desistir aplicação android, em vez disso, vai no fundo ...
Jayesh
5

(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
}
trante
fonte
3

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

Isham
fonte
3

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.

Irshu
fonte
Boa abordagem. Não há necessidade de passar valores via Intent.
user3144836
0

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

android.os.Process.killProcess(android.os.Process.myPid());
super.onDestroy();
Ramanathan
fonte
0

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;
        }
    }
}
Amol Sawant 96 Kuli
fonte
0

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'
}
}
Caçador
fonte
0

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);
}
Dila Gurung
fonte
0

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

        }
    });
Vivek Akkaldevi
fonte
0

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

Espero que ajude.

patel dhruval
fonte
0

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;
    }
Produção Bokili
fonte
-2

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);
}
Pir Fahim Shah
fonte