Come uscire dall'applicazione e mostrare la schermata principale?

Ho un'applicazione in cui nella home page ho i pulsanti per la navigazione attraverso l'applicazione.

In quella pagina ho un pulsante "EXIT" che quando viene cliccato dovrebbe portare l'utente alla schermata principale sul telefono dove si trova l'icona dell'applicazione.

Come lo posso fare?

Il design di Android non favorisce l'uscita da un'applicazione per scelta, ma piuttosto la gestisce dal sistema operativo. Puoi visualizzare l'applicazione Home in base al suo Intento corrispondente:

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

Forse puoi provare qualcosa del genere

Supponiamo che nella nostra applicazione abbiamo una serie di attività (diciamo dieci) e che dobbiamo uscire direttamente da questa attività. Quello che possiamo fare è, creare un intento e andare all'attività di root e impostare flag nell'intento come

intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);

inoltre, aggiungi qualche extra come booleano all'intento

intent.putExtra("EXIT", true);

Quindi, nell'attività root, controlla il valore di booleane in base a quella chiamata finish (), nell'attività onCreate()root

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

System.exit(0);

È probabilmente quello che stai cercando. Chiuderà l'intera applicazione e ti porterà alla schermata principale.

Questo funziona bene per me.
Chiudi tutte le attività precedenti come segue:

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

Quindi nel metodo MainActivity onCreate () aggiungilo per completare MainActivity

    setContentView(R.layout.main_layout);

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

per prima cosa completa l'applicazione usando il metodo finish();

e quindi aggiungi le righe sottostanti in onDestroy per la rimozione della forza di chiusura

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

Se vuoi terminare un'attività puoi semplicemente chiamare finish(). È comunque una cattiva pratica avere un pulsante di uscita sullo schermo.

Alcune attività in realtà non si desidera riaprire quando si preme il pulsante Indietro, ad esempio Attività schermata iniziale, Attività schermata iniziale, Finestre di conferma. In realtà non è necessario questo nello stack di attività. puoi farlo usando => apri il file manifest.xml e aggiungi un attributo

Android: noHistory = "true"

a queste attività.

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

O

A volte si desidera chiudere l'intera applicazione premendo un certo pulsante Indietro. Qui la best practice è aprire la finestra principale invece di uscire dall'applicazione. Per questo è necessario sovrascrivere il metodo onBackPressed (). di solito questo metodo apre l'attività principale nello stack.

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

}

O

Nel pulsante Indietro premuto vuoi uscire da quell'attività e inoltre non vuoi aggiungerlo nello stack di attività. chiama il metodo finish () all'interno del metodo onBackPressed (). non chiuderà l'intera applicazione. andrà per l'attività precedente nello stack.

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

Non è consigliabile uscire dall'applicazione Android. Vedi questa domanda per maggiori dettagli.

L'utente può sempre uscire dall'app tramite il pulsante Home o nella prima attività tramite il pulsante Indietro.

(Ho provato le risposte precedenti ma mancano in alcuni punti. Ad esempio se non lo fai return; dopo aver terminato, il codice attività rimanente viene eseguito. Inoltre è necessario modificare onCreate con ritorno. Se non si esegue super.onCreate () otterrai un errore di runtime)

Di 'che hai MainActivitye ChildActivity.

Inside ChildActivity aggiungi questo:

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

OnCreate di MainActivity aggiungi questo:

@Override
public void onCreate(Bundle savedInstanceState) {

    mContext = getApplicationContext();

    super.onCreate(savedInstanceState);

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

Esiste un'altra opzione per utilizzare il metodo FinishAffinity per chiudere tutte le attività nello stack relative all'app.

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

Quando chiamerai finish, verrà chiamata onDestroy () di quell'attività e tornerà all'attività precedente nello stack di attività ... Quindi .. per uscire non chiamare finish ();

Ecco cosa ho fatto:

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

Fondamentalmente quello che hai fatto è stato cancellato tutte le attività dallo stack e dal lancio QuitAppActivity, che completerà l'attività.

Aggiungi le seguenti righe dopo finish();in onDestroy():

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

Ho provato a uscire dall'applicazione usando il seguente frammento di codice, questo ha funzionato per me. Spero che questo ti aiuti. ho fatto una piccola demo con 2 attività

prima attività

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

qualsiasi altra attività

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

L'ho fatto con la modalità osservatore.

Interfaccia osservatore

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

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

Il soggetto figlio implementa il metodo di uscita

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

MyApplication quale applicazione dovrebbe estenderla

public class MyApplication extends Application {

private static ApplicationSubject applicationSubject;

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

}

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

}

proviamolo

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

se vuoi uscire dall'applicazione metti questo codice sotto la tua funzione

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% funziona bene. questo è il codice per uscire dall'app onClick (metodo)

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

        }
    });

Puoi semplicemente aggiungere moveTaskToBack(true)il pulsante di uscita onClickedListenerper ridurre al minimo l'applicazione.

Spero che sia d'aiuto.

Forse il mio codice può 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 vuoi uscire dalla tua applicazione. Quindi utilizzare questo codice all'interno dell'evento premuto pulsante. piace:

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