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

195

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ć?

poojan9118
źródło

Odpowiedzi:

326

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);
ognian
źródło
25
Możesz nawet użyć .. "moveTaskToBack (true);"
hemanth kumar
17
czy przeniesie wszystkie zasoby? Ponieważ kiedy wychodzę z aplikacji w ten sposób i po pewnym czasie ponownie klikam ikonę aplikacji. Zaczyna się od miejsca, w którym go zostawiłem. Oznacza to, że aplikacja nadal działała w tle.
Adil Malik
12
Activity.finish ();
hB0
11
Dzięki temu Twoja aplikacja jest w tle, więc nie wychodzi z niej.
Herman Schoenfeld
3
Ta odpowiedź spowoduje, że pojawi się ekran główny i nie zamknie / nie zamknie aplikacji całkowicie, jak chce OP.
Basher51
74

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();
}
Kartik Domadiya
źródło
1
Po prostu nie rób nic w onCreate, aby wywołać wykończenie.
imcaptor,
2
W moim przypadku również musiałem to zmienić onNewIntent. Ponieważ intnet.getExtras () wciąż ma wartość NULL.
zznq
I ta metoda zrestartuje twój RootActivityzamiast wznawiać go ze stosu. Sprawdź tutaj, aby przezwyciężyć ten stackoverflow.com/a/26258455/609782
Darpan
28
System.exit(0);

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

Ndupza
źródło
1
Czy powinno to być małe wyjście?
Carol
1
powinna być System.exit (0). Ale i tak nie jest to bardzo przydatne.
superarts.org,
7
System.exit (0) nie powinien być używany zgodnie z zaleceniami głównego zespołu Androida.
Dinesh Venkata,
2
Myślę, że to najlepsze podejście do wyjątkowych okoliczności. Powiedz o aplikacji, która potrzebuje Internetu, a połączenie przerywa kilka czynności w aplikacji. Można wyświetlić okno dialogowe z ostrzeżeniem (bez przycisków). Przycisk Wstecz musi wyjść z całej aplikacji, ponieważ ponowne wejście wymaga ponownego zalogowania / zainicjowania. System.exit to jedyna rzecz, która działa rozsądnie, którą znalazłem. Nie jestem jednak pewien co do komentarza @ user1699548.
Herman Schoenfeld
1
Czy to zabije również wszystkie usługi związane z tą aplikacją?
bsara,
25

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
    }
Leniwy Ninja
źródło
To mi nie działa. Nie pozostawia mojej aplikacji widocznej, ale nadal działa. Widzę wątki wiszące i czekające w debuggerze, które nigdy nic nie zrobią.
Stephen M. - strajk -
23

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

źródło
3
nigdy tego nie używaj, ponieważ nie ma szans na uwolnienie zasobów
Jacky
1
-1, ponieważ onDestroy jest wykonywany za każdym razem, gdy opuszczasz działanie, nie tylko po naciśnięciu klawisza Wstecz.
Hamzeh Soboh
5
@Jacky: a jak zabicie procesu nie zwalnia żadnych zasobów systemowych?
Herman Schoenfeld
1
Dlaczego jest super.onDestroy()po killProcess()? czy ta linia zostanie w ogóle osiągnięta?
shoosh,
czy to również nie zabija wszystkich twoich usług?
Irshu
20

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

chrześcijanin
źródło
2
Używam go do „Musisz zaktualizować tę aplikację do najnowszej wersji” i nie chcę, aby nadal z niej korzystali. Wciąż zła praktyka ...?
buraków
@beetree Tak. Jak każda zła praktyka, zdarzają się przypadki, gdy jest to twoja jedyna opcja i używasz jej, ponieważ próba zrobienia czegoś innego byłaby bezsensowna. Chodzi o to, że jest to zła praktyka , w przeciwieństwie do nielegalnej składni , dlatego, że jest dostępna w tych kilku przypadkach, ale powinieneś spróbować swoich sił, aby znaleźć lepszy sposób na to. W twoim przypadku nie ma takiego.
Pozew funduszu Moniki z
17

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();
}
Buru
źródło
16

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.

Janusz
źródło
3
@janusz: naciśnięcie przycisku Home nigdy nie wychodzi z aplikacji na Androida, zamiast tego idzie w tle ...
Jayesh
5

(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
}
trante
źródło
3

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

Isham
źródło
3

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.

Irshu
źródło
Dobre podejscie. Nie ma potrzeby przekazywania wartości przez zamiar.
user3144836
0

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

android.os.Process.killProcess(android.os.Process.myPid());
super.onDestroy();
Ramanathan
źródło
0

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;
        }
    }
}
Amol Sawant 96 Kuli
źródło
0

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'
}
}
myśliwy
źródło
0

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);
}
Dila Gurung
źródło
0

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

        }
    });
Vivek Akkaldevi
źródło
0

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

Mam nadzieję, że to pomoże.

patel dhruval
źródło
0

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;
    }
Produkcja Bokili
źródło
-2

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);
}
Pir Fahim Shah
źródło