Jak wyjść z aplikacji i wyświetlić ekran główny?

Mam aplikację, w której na stronie głównej mam przyciski do nawigacji po aplikacji.

Na tej stronie mam przycisk „EXIT”, który po kliknięciu powinien przenieść użytkownika na ekran główny telefonu, na którym znajduje się ikona aplikacji.

Jak mogę to zrobić?

Projekt Androida nie sprzyja opuszczaniu aplikacji z wyboru, ale raczej zarządza nią przez system operacyjny. Możesz wywołać aplikację Home, odpowiadającą jej celom:

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

Być może możesz spróbować czegoś takiego

Załóżmy, że w naszej aplikacji mamy szereg działań (powiedzmy dziesięć) i musimy wyjść bezpośrednio z tego działania. Co możemy zrobić, to stworzyć intencję i przejść do działania roota i ustawić flagę w intencji jako

intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);

dodaj też dodatkowe intencje, takie jak boolean

intent.putExtra("EXIT", true);

Następnie w działaniu root sprawdź wartość booleani zgodnie z tym wywołaniem kończącym () w onCreate()działaniu root

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

System.exit(0);

Jest prawdopodobnie tym, czego szukasz. Spowoduje to zamknięcie całej aplikacji i przejście do ekranu głównego.

To działa dobrze dla mnie.
Zamknij wszystkie poprzednie działania w następujący sposób:

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

Następnie w metodzie MainActivity onCreate () dodaj to, aby zakończyć MainActivity

    setContentView(R.layout.main_layout);

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

najpierw zakończ swoją aplikację przy użyciu metody finish();

a następnie dodaj poniższe wiersze w onDestroy do usuwania siły zamknięcia

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

Jeśli chcesz zakończyć działanie, możesz po prostu zadzwonić finish(). Jednak złą praktyką jest posiadanie przycisku wyjścia na ekranie.

Niektórych działań nie chcesz ponownie otwierać po naciśnięciu przycisku Wstecz, np. Aktywność ekranu powitalnego, Aktywność ekranu powitalnego, Windows z potwierdzeniem. W rzeczywistości nie potrzebujesz tego w stosie działań. możesz to zrobić za pomocą => otwórz plik manifest.xml i dodaj atrybut

android: noHistory = "true"

do tych działań.

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

LUB

Czasami chcesz zamknąć całą aplikację po pewnym naciśnięciu przycisku Wstecz. Tutaj najlepszą praktyką jest otwieranie okna głównego zamiast zamykania aplikacji. W tym celu należy zastąpić metodę onBackPressed (). zwykle ta metoda otwiera najwyższą aktywność na stosie.

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

}

LUB

Po naciśnięciu przycisku Wstecz chcesz wyjść z tego działania, a także nie chcesz dodawać tego do stosu działań. Wywołaj metodę finish () wewnątrz metody onBackPressed (). nie spowoduje to zamknięcia całej aplikacji. przejdzie do poprzedniej aktywności na stosie.

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

Nie zaleca się zamykania aplikacji Android. Zobacz to pytanie, aby uzyskać więcej informacji.

Użytkownik może zawsze zamknąć aplikację za pomocą przycisku strony głównej lub podczas pierwszej aktywności za pomocą przycisku wstecz.

(Próbowałem wcześniejszych odpowiedzi, ale brakuje im niektórych punktów. Na przykład, jeśli nie wykonasz czynności return;po zakończeniu, pozostanie kod aktywności jest uruchamiany. Musisz także edytować onCreate z return. Jeśli nie uruchomisz super.onCreate () pojawi się błąd czasu wykonywania)

Powiedz, że masz MainActivityi ChildActivity.

Wewnątrz ChildActivity dodaj to:

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

Wewnątrz onCreate MainActivity dodaj to:

@Override
public void onCreate(Bundle savedInstanceState) {

    mContext = getApplicationContext();

    super.onCreate(savedInstanceState);

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

Jest jeszcze jedna opcja, aby użyć metody FinishAffinity, aby zamknąć wszystkie zadania na stosie związane z aplikacją.

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

Kiedy wywołasz metodę wykończenia, wywołana zostanie funkcja onDestroy () tego działania, która powróci do poprzedniej czynności na stosie działań ... Więc ... w celu zakończenia nie wywołuj metody finish ();

Oto co zrobiłem:

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

Zasadniczo to, co zrobiłeś, to wyczyszczenie wszystkich działań ze stosu i uruchomienie QuitAppActivity, które zakończy zadanie.

Dodaj następujący po liniach finish();w onDestroy():

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

Próbowałem wyjść z aplikacji przy użyciu następującego fragmentu kodu, to zadziałało dla mnie. Mam nadzieję, że to ci pomoże. Zrobiłem małe demo z 2 aktywnościami

pierwsza aktywność

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

Twoja inna działalność

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

Zrobiłem to w trybie obserwatora.

Interfejs obserwatora

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

Temat podstawowy

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

Podmiot podrzędny implementuje metodę wyjścia

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

MyApplication, którą aplikacja powinna rozszerzyć

public class MyApplication extends Application {

private static ApplicationSubject applicationSubject;

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

}

Podstawowa aktywność

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

}

przetestujmy to

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

jeśli chcesz wyjść z aplikacji, umieść ten kod pod swoją funkcją

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% działa dobrze. to jest kod do wyjścia z aplikacji onClick (metoda)

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

        }
    });

Możesz po prostu dodać moveTaskToBack(true)przycisk wyjścia, onClickedListeneraby zminimalizować aplikację.

Mam nadzieję, że to pomoże.

Może mój kod potrafi 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;
    }

Jeśli chcesz wyjść z aplikacji. Następnie użyj tego kodu wewnątrz zdarzenia naciśnięcia przycisku. lubić:

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