Jak programowo zamknąć aplikację na Androida

Znalazłem trochę kodów, aby programowo zamknąć aplikację na Androida. Wywołując dowolny z poniższych kodów w onDestroy (), czy całkowicie zamknie aplikację?

1. System.runFinalizersOnExit(true)
   (LUB)
2. android.os.Process.killProcess(android.os.Process.myPid());

Nie chcę uruchamiać aplikacji w tle po kliknięciu przycisku Zamknij. Pls sugerują, że mogę użyć dowolnego z tych kodów, aby zamknąć aplikację? Jeśli tak, jakiego kodu mogę użyć? Czy to dobry sposób na zamknięcie aplikacji na Androida?

Od API 16 możesz używać metody finishAffinity, która wydaje się być bardzo bliska zamknięcia wszystkich powiązanych działań według jej nazwy i opisu Javadoc:

this.finishAffinity ();

Zakończ to działanie, a także wszystkie działania bezpośrednio pod nim w bieżącym zadaniu, które mają to samo powinowactwo. Jest to zwykle używane, gdy aplikacja może zostać uruchomiona do innego zadania (na przykład z ACTION_VIEW typu treści, który rozumie), a użytkownik skorzystał z nawigacji w górę, aby przełączyć się z bieżącego zadania do własnego. W takim przypadku, jeśli użytkownik przejdzie w dół do innych działań drugiej aplikacji, wszystkie z nich powinny zostać usunięte z pierwotnego zadania jako część przełącznika zadań.

Pamiętaj, że to wykończenie nie pozwala na dostarczenie wyników do poprzedniej aktywności, a wyjątek zostanie zgłoszony, jeśli spróbujesz to zrobić.

Od API 21 możesz użyć bardzo podobnego polecenia

finishAndRemoveTask ();

Kończy wszystkie działania w tym zadaniu i usuwa je z listy ostatnich zadań.

getActivity().finish();
System.exit(0);

jest to najlepszy sposób na zamknięcie aplikacji. !!!

Najlepsze rozwiązanie dla mnie.

finishAffinity();

System.exit(0);

Jeśli będziesz używać tylko finishAffinity();bez System.exit(0);aplikacji, aplikacja zostanie zamknięta, ale przydzielona pamięć będzie nadal używana przez telefon, więc ... jeśli chcesz mieć czystą i naprawdę zamkniętą aplikację, użyj obu z nich.

Jest to najprostsza metoda i działa wszędzie. Wyjdź z aplikacji na poważnie, możesz mieć dużo otwartej aktywności, a mimo to zakończyć wszystko bez problemu.

przykład na kliknięcie przycisku

public void exitAppCLICK (View view) {

    finishAffinity();
    System.exit(0);

}

lub jeśli chcesz czegoś ładnego, na przykład z oknem dialogowym z 3 przyciskami TAK NIE i ANULUJ

// alertdialog for exit the app
AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(this);

// set the title of the Alert Dialog
alertDialogBuilder.setTitle("your title");

// set dialog message
alertDialogBuilder
        .setMessage("your message")
        .setCancelable(false)
        .setPositiveButton("YES"),
                new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog,
                                        int id) {
                        // what to do if YES is tapped
                        finishAffinity();
                        System.exit(0);
                    }
                })

        .setNeutralButton("CANCEL"),
                new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog,
                                        int id) {
                        // code to do on CANCEL tapped
                        dialog.cancel();
                    }
                })

        .setNegativeButton("NO"),
                new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog,
                                        int id) {
                        // code to do on NO tapped
                        dialog.cancel();
                    }
                });

AlertDialog alertDialog = alertDialogBuilder.create();

alertDialog.show();

Zastanów się, czy musisz zabić aplikację: dlaczego nie pozwolić systemowi operacyjnemu dowiedzieć się, gdzie i kiedy zwolnić zasoby?

W przeciwnym razie, jeśli jesteś absolutnie pewien, użyj

finish();

W reakcji na komentarz apleta @dave: Najpierw przeczytaj dużą kombinację pytań / odpowiedzi @gabriel: Czy rezygnacja z aplikacji jest niezadowolona ?

Teraz, zakładając, że tak jest, pytanie tutaj wciąż ma odpowiedź, ponieważ kod, którego potrzebujesz, jeśli robisz cokolwiek z rezygnacją, to finish(). Oczywiście możesz mieć więcej niż jedną aktywność itp., Ale nie o to chodzi. Pozwala uruchomić niektóre przypadki użycia

1. Chcesz, aby użytkownik rzucił wszystko ze względu na zużycie pamięci i „nie działa w tle? Wątpliwe. Pozwól użytkownikowi zatrzymać określone działania w tle, ale pozwól systemowi operacyjnemu zabić wszelkie niepotrzebne odwołania.
2. Chcesz, aby użytkownik nie przechodził do poprzedniej aktywności Twojej aplikacji? Cóż, albo skonfiguruj to, żeby nie działało, albo potrzebujesz dodatkowej opcji. Jeśli przez większość czasu działa wstecz = poprzednia aktywność, czy użytkownik nie po prostu naciska domu, jeśli chce zrobić coś innego?
3. Jeśli potrzebujesz resetowania, możesz dowiedzieć się, czy / jak / etc Twoja aplikacja została zamknięta, a jeśli aktywność znów się skupi, możesz podjąć działania w tym celu, pokazując nowy ekran zamiast restartować się tam, gdzie byłeś.

Ostatecznie rzecz jasna finish()nic nie zabija, ale myślę, że nadal jest to narzędzie, którego potrzebujesz. Jeśli istnieje przypadek użycia dla „zabicia wszystkich działań”, jeszcze go nie znalazłem.

Myślę, że w niektórych przypadkach aplikacja powinna zostać zabita. Na przykład istnieje aplikacja, z której można korzystać tylko po zalogowaniu. Aktywność logowania ma dwa przyciski: „login” i „Cancel”. Kliknięcie przycisku „Anuluj” oznacza zdecydowanie „Zakończ aplikację”. Nikt nie chce aplikacji w tle. Zgadzam się więc, że niektóre przypadki wymagają wyłączenia aplikacji.

Utwórz a ExitActivityi zadeklaruj to w manifeście. I wzywaj ExitActivity.exit(context)do opuszczenia aplikacji.

public class ExitActivity extends AppCompatActivity {

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

    public static void exit(Context context) {
        Intent intent = new Intent(context, ExitActivity.class);
        intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK);
        context.startActivity(intent);
    }

}

W Androidzie nie ma aplikacji zamykającej się, SampleActivity.this.finish (); zakończy bieżącą aktywność.

Kiedy przełączasz się z jednej czynności na drugą, kontynuuj poprzednią

Intent homeintent = new Intent(SampleActivity.this,SecondActivity.class);
startActivity(homeintent);
SampleActivity.this.finish();

Przede wszystkim takie podejście wymaga min Api 16.

Podzielę to rozwiązanie na 3 części, aby szerzej rozwiązać ten problem.

1. Jeśli chcesz zamknąć aplikację w działaniu, użyj tego fragmentu kodu:

if(Build.VERSION.SDK_INT>=16 && Build.VERSION.SDK_INT<21){
    finishAffinity();
} else if(Build.VERSION.SDK_INT>=21){
    finishAndRemoveTask();
}

2. Jeśli chcesz zamknąć aplikację w klasie innej niż Activity, która ma dostęp do Activity, użyj tego fragmentu kodu:

if(Build.VERSION.SDK_INT>=16 && Build.VERSION.SDK_INT<21){
    getActivity().finishAffinity();
} else if(Build.VERSION.SDK_INT>=21){
    getActivity().finishAndRemoveTask();
}

3. Jeśli chcesz zamknąć aplikację w klasie innej niż Activity i nie możesz uzyskać dostępu do Activity, takiej jak Service, polecam użyć BroadcastReceiver. Możesz dodać to podejście do wszystkich swoich działań w swoim projekcie.

Utwórz zmienne instancji LocalBroadcastManager i BroadcastReceiver. Jeśli chcesz, możesz zastąpić getPackageName () + „. Closeapp”.

LocalBroadcastManager mLocalBroadcastManager;
BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() {
    @Override
    public void onReceive(Context context, Intent intent) {
        if(intent.getAction().equals(getPackageName()+".closeapp")){
            if(Build.VERSION.SDK_INT>=16 && Build.VERSION.SDK_INT<21){
                finishAffinity();
            } else if(Build.VERSION.SDK_INT>=21){
                finishAndRemoveTask();
            }
        }
    }
};

Dodaj je do metody działania OnCreate ().

mLocalBroadcastManager = LocalBroadcastManager.getInstance(this);
IntentFilter mIntentFilter = new IntentFilter();
mIntentFilter.addAction(getPackageName()+".closeapp");
mLocalBroadcastManager.registerReceiver(mBroadcastReceiver, mIntentFilter);

Nie zapomnij też wywołać funkcji wyrejestrowania odbiornika w metodzie działania onDestroy ()

mLocalBroadcastManager.unregisterReceiver(mBroadcastReceiver);

Aby zakończyć aplikację, musisz wysłać transmisję za pomocą LocalBroadcastManager, którego używam w mojej klasie PlayService, która rozszerza usługę.

LocalBroadcastManager localBroadcastManager = LocalBroadcastManager.getInstance(PlayService.this);
localBroadcastManager.sendBroadcast(new Intent(getPackageName() + ".closeapp"));

Możesz używać finishAndRemoveTask ()z API 21

public void finishAndRemoveTask ()

Kończy wszystkie działania w tym zadaniu i usuwa je z listy ostatnich zadań.

To zależy od tego, jak szybko chcesz zamknąć aplikację.

Bezpiecznym sposobem na zamknięcie Twojej aplikacji jest finishAffinity ();

Zamyka aplikację po zakończeniu przetwarzania wszystkich procesów. Może to wymagać trochę czasu. Jeśli zamkniesz aplikację w ten sposób i uruchomisz ją ponownie po krótkim czasie, możliwe, że Twoja nowa aplikacja działa w tym samym procesie. Ze wszystkimi nieukończonymi procesami i obiektami singletonowymi starej aplikacji.

Jeśli chcesz mieć pewność, że Twoja aplikacja jest całkowicie zamknięta, użyj System.exit (0);

Spowoduje to natychmiastowe zamknięcie Twojej aplikacji. Ale możliwe jest, że uszkodzisz pliki, które otworzyła Twoja aplikacja lub edytowanie wspólnych preferencji się nie zakończy. Więc używaj tego ostrożnie.

Jeśli używasz watchdoga w połączeniu z długo działającym zadaniem, możesz zobaczyć wpływy różnych metod.

new ANRWatchDog(2000).setANRListener(new ANRWatchDog.ANRListener() {
    public void onAppNotResponding(ANRError error) {
        MainActivity.this.finishAffinity();
        System.exit(0);
    }
}).start();
for(int i = 0; i < 10; ++i){
    --i;
}

To zabija twoją aplikację po 2 sekundach bez wyświetlania okna dialogowego ANR lub czegoś podobnego. Jeśli usuniesz System.exit (0) , uruchom ten kod i uruchom ponownie aplikację po jej zamknięciu, wystąpią dziwne zachowania, ponieważ nieskończona pętla nadal działa.

Lepiej skorzystaj, finish()jeśli jesteś w Activitylub getActivity().finish()jeśli jesteś w Fragment.

Jeśli chcesz całkowicie zamknąć aplikację, użyj:

getActivity().finish();
System.exit(0);

Łatwy i prosty sposób na wyjście z aplikacji

Intent homeIntent = new Intent(Intent.ACTION_MAIN);
homeIntent.addCategory(Intent.CATEGORY_HOME);
homeIntent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
startActivity(homeIntent);

Chcemy kodu, który jest solidny i prosty. To rozwiązanie działa na starszych urządzeniach i nowszych urządzeniach.

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
        getActivity().finishAffinity();
    } else{
        getActivity().finish();
        System.exit( 0 );
    }

Myślę, że właśnie tego szukasz

activity.moveTaskToBack(Boolean nonRoot);

public void quit() {
        int pid = android.os.Process.myPid();
        android.os.Process.killProcess(pid);
        System.exit(0);
    }

Podobne do @MobileMateo, ale w Kotlinie

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
    this.finishAffinity()
} else{
    this.finish()
    System.exit(0)
}

Nie jestem pewny, czy to się marszczy, czy nie, ale tak to robię ...

Krok 1 - Zazwyczaj mam klasę, która zawiera metody i zmienne, do których chcę uzyskać dostęp globalnie. W tym przykładzie nazywam to klasą „App”. Utwórz statyczną zmienną Activity wewnątrz klasy dla każdego działania, które ma Twoja aplikacja. Następnie utwórz metodę statyczną o nazwie „close”, która uruchomi tę finish()metodę dla każdej ze zmiennych Activity, jeśli NIE są one zerowe . Jeśli masz aktywność główną / rodzicielską, zamknij ją na końcu:

public class App
{
    ////////////////////////////////////////////////////////////////
    // INSTANTIATED ACTIVITY VARIABLES
    ////////////////////////////////////////////////////////////////

        public static Activity activity1;
        public static Activity activity2;
        public static Activity activity3;

    ////////////////////////////////////////////////////////////////
    // CLOSE APP METHOD
    ////////////////////////////////////////////////////////////////

        public static void close()
        {
            if (App.activity3 != null) {App.activity3.finish();}
            if (App.activity2 != null) {App.activity2.finish();}
            if (App.activity1 != null) {App.activity1.finish();}
        }
}

Krok 2 - w każdej ze swoich czynności zastąp metody onStart()i onDestroy(). W onStart()ustaw zmienną statyczną w swojej klasie aplikacji na „ this”. W onDestroy()ustaw wartość równą null. Na przykład w klasie „Activity1”:

@Override
public void onStart()
{
    // RUN SUPER | REGISTER ACTIVITY AS INSTANTIATED IN APP CLASS

        super.onStart();
        App.activity1 = this;
}

@Override
public void onDestroy()
{
    // RUN SUPER | REGISTER ACTIVITY AS NULL IN APP CLASS

        super.onDestroy();
        App.activity1 = null;
}

Krok 3 - Jeśli chcesz zamknąć aplikację, po prostu zadzwoń App.close()z dowolnego miejsca. Wszystkie tworzone instancje zostaną zamknięte! Ponieważ tylko zamykasz działania, a nie zabijasz samej aplikacji (jak w twoich przykładach), Android może przejąć stamtąd i wykonać niezbędne porządki.

Znów nie wiem, czy byłoby to z jakiegoś powodu krzywdzone. Jeśli tak, chciałbym przeczytać komentarze na temat tego, dlaczego tak jest i jak można to poprawić!

Czy odrzucenie aplikacji jest niezadowolone? . Przejdź przez ten link. Odpowiada na twoje pytanie. System wykonuje zadanie polegające na zabiciu aplikacji.

Załóżmy, że masz dwie czynności A i B. Poruszasz się od A do B. Po kliknięciu przycisku Wstecz aktywność B zostaje wyrzucona z plecaka i zniszczona. Poprzednia aktywność w czynności A stosu tylnego jest skoncentrowana.

Powinieneś pozostawić to systemowi, aby zdecydował, kiedy zabić aplikację.

pustka publiczna finish()

Zadzwoń, gdy aktywność zostanie zakończona i powinna zostać zamknięta.

Załóżmy, że masz wiele działań. możesz użyć paska akcji. Po kliknięciu ikony strony głównej przejdź do MainActivity aplikacji. W MainActivity kliknij przycisk Wstecz, aby wyjść z aplikacji.

Aby wyjść z aplikacji, możesz użyć:

getActivity().finish();
Process.killProcess(Process.myPid());
System.exit(1);

Aby również zatrzymać usługi, wywołaj następującą metodę:

private void stopServices() {        
    final ActivityManager activityManager = SystemServices.getActivityManager(context);
    final List<ActivityManager.RunningServiceInfo> runningServices = activityManager.getRunningServices(Integer.MAX_VALUE);
    final int pid = Process.myPid();
    for (ActivityManager.RunningServiceInfo serviceInfo : runningServices) {
        if (serviceInfo.pid == pid && !SenderService.class.getName().equals(serviceInfo.service.getClassName())) {
            try {
                final Intent intent = new Intent();
                intent.setComponent(serviceInfo.service);
                context.stopService(intent);
            } catch (SecurityException e) { 
                 // handle exception
            }
        }
    }
}

Może to być bardzo późno, a także zgodnie z wytycznymi nie powinieneś sam zajmować się cyklem życia (tak jak robi to OS). Sugeruje się, aby zarejestrować odbiornik radiowy we wszystkich swoich działaniach za pomocą „ finish()” w jego onReceive() i za każdym razem, gdy chcesz wyjść, możesz po prostu przekazać zamiar wskazujący, że wszystkie działania muszą zostać zamknięte ..... Pamiętaj jednak, aby to zrobić ” wyrejestruj odbiornik w swoich onDestroy()metodach.

To nie jest dobra decyzja, ponieważ jest niezgodna z zasadami przetwarzania aplikacji na Androida. Android nie zabija żadnego procesu, chyba że jest to absolutnie nieuniknione. Pomaga to aplikacjom uruchamiać się szybciej, ponieważ zawsze są przechowywane w pamięci. Potrzebujesz więc specjalnego powodu, by zabić proces aplikacji.

Prawidłowe i dokładne rozwiązanie, aby zamknąć aplikację po kliknięciu przycisku, wykorzystuje poniższy kod:

// Zdarzenie naciśnięcia przycisku Wstecz

public void onBackPressed()
{ 
   moveTaskToBack(true);
   finish();
}

Jeśli używasz Kotlina, właściwym sposobem na wyjście z aplikacji i alternatywą System.exit()jest wbudowana metoda

exitProcess(0)

Zobacz dokumentację .

Liczba 0jako parametr oznacza, że ​​wyjście jest zamierzone i nie wystąpił błąd.

To wszystko zabije;)

int p = android.os.Process.myPid();
android.os.Process.killProcess(p);

Spróbuj tego

int pid = android.os.Process.myPid();
android.os.Process.killProcess(pid);

Najłatwiejszy sposób, aby wyjść z aplikacji z działania, bez łamania logiki Androida i bez dodawania więcej kodu do istniejących działań i przekazywania dodatków to:

public static void quitApplication (Activity currentActivity) {
    Intent intent = new Intent (currentActivity, QuitApplicationActivity.class);
    intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK | Intent.FLAG_ACTIVITY_CLEAR_TOP);

    currentActivity.startActivity (intent);
    currentActivity.finish ();
}

QuitApplicationActivitysamopoczucie:

public class QuitApplicationActivity extends AppCompatActivity {

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

        finish ();
    }
}

Odpowiedź @Sivi zamyka aplikację. Ale po powrocie, jeśli masz jakieś zajęcia dla dzieci, może zostać otwarte inne niedokończone działanie. Dodałem noHistory:truedo moich działań, więc aplikacja po powrocie zaczyna się od MainActivity.

<activity 
      android:name=".MainActivity"
      android:noHistory="true">
</activity>

Aby dodać jedną do listy brutalnych metod zamykania aplikacji:

Process.sendSignal(Process.myPid(), Process.SIGNAL_KILL);

możesz zakończyć swoje pełne aplikacje. a zatem

Intent intent = getBaseContext().getPackageManager()
             .getLaunchIntentForPackage(getBaseContext().getPackageName());
intent .addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
startActivity(intent);

będzie działać w 100%. Powodzenia!

Po prostu użyj Finish () na tylnym klawiszu naciśnij onKeypressed ()