Jak programowo zamknąć aplikację na Androida?

Jestem pewien, że to pytanie zostało zadane wiele razy, ponieważ przeczytałem kilka. Mój klient chce, żebym umieścił przycisk w jego aplikacji, w którym użytkownicy mogą kliknąć i wyjść. Przeczytałem to i stwierdziłem, że zadzwonienie finish()wystarczy. Ale zakończenie to tylko zamknięcie bieżącej aktywności, prawda? Mam wiele działań, więc w tym przypadku muszę przejść każdą instancję działania i zakończyć je lub uczynić każdą aktywność we wzorcu Singleton.

Dowiedziałem się również, że Activity.moveTaskToBack(true)może przenieść Cię na ekran główny. OK, to nie jest zamknięcie, ale kontynuacja procesu. Czy to jest skuteczne?

Której metody należy użyć, aby całkowicie zamknąć aplikację? Któryś z wyżej opisanych lub inny sposób / inne zastosowanie powyższych metod?

Właściwie każdy szuka zamknięcia aplikacji na zdarzeniu onclick, gdziekolwiek może być aktywność ....

Więc przyjaciele faceci próbują tego kodu. Umieść ten kod w zdarzeniu onclick

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

Możesz wywołać System.exit (); wyjść ze wszystkich zajęć.

    submit=(Button)findViewById(R.id.submit);

            submit.setOnClickListener(new OnClickListener() {

                @Override
                public void onClick(View arg0) {
android.os.Process.killProcess(android.os.Process.myPid());
                    System.exit(1);

                }
            });

Metoda finishAffinity, wydana w API 16, zamyka wszystkie trwające działania i zamyka aplikację:

this.finishAffinity();

Zakończ tę czynność, a także wszystkie czynności bezpośrednio pod nią w bieżącym zadaniu, które mają to samo podobieństwo. Jest to zwykle używane, gdy aplikacja może zostać uruchomiona w innym zadaniu (na przykład z ACTION_VIEW typu treści, który rozumie), a użytkownik wykorzystał nawigację w górę, aby przełączyć się z bieżącego zadania do własnego zadania. W takim przypadku, jeśli użytkownik przeszedł w dół do innych działań drugiej aplikacji, wszystkie z nich należy usunąć z pierwotnego zadania w ramach przełączania zadań.

Zwróć uwagę, że to zakończenie nie pozwala na dostarczenie wyników do poprzedniego działania, a jeśli spróbujesz to zrobić, zostanie zgłoszony wyjątek.

Od API 21 możesz używać:

finishAndRemoveTask();

Kończy wszystkie czynności w tym zadaniu i usuwa je z listy ostatnich zadań.

Alternatywy:

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

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

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

Intent i = new Intent(context, LoginActivity.class);
i.putExtra(EXTRA_EXIT, true);
i.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
i.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
i.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK);
context.startActivity(i);

Źródło: Jak programowo zamknąć aplikację na Androida

Mam nadzieję, że to pomoże! Powodzenia!

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

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

 @Override
    public void onBackPressed() {
        AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(this);
        alertDialogBuilder.setTitle("Exit Application?");
        alertDialogBuilder
                .setMessage("Click yes to exit!")
                .setCancelable(false)
                .setPositiveButton("Yes",
                        new DialogInterface.OnClickListener() {
                            public void onClick(DialogInterface dialog, int id) {
                                moveTaskToBack(true);
                                android.os.Process.killProcess(android.os.Process.myPid());
                                System.exit(1);
                            }
                        })

                .setNegativeButton("No", new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog, int id) {

                        dialog.cancel();
                    }
                });

        AlertDialog alertDialog = alertDialogBuilder.create();
        alertDialog.show();
    }

To zbyt łatwe. Posługiwać sięSystem.exit(0);

Oczywiście istnieją dwie możliwe sytuacje:

1. Możesz wyjść z zajęć
2. Lub chcesz wyjść z aplikacji

Możesz wyjść z aktywności za pomocą następującego kodu:

var intent = new Intent(Intent.ActionMain);
intent.AddCategory(Intent.CategoryHome);
intent.SetFlags(ActivityFlags.NewTask);
startActivity(intent);
finish();

Ale to nie zabije podstawowych działań w tej samej aplikacji. To po prostu zminimalizuje aplikację.

Jeśli chcesz wyjść z aplikacji, użyj następującego kodu, aby zakończyć jej proces:

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

do rozwoju mono po prostu użyj

process.KillProcess(Process.MyPid());

Co powiesz na this.finishAffinity()

Z dokumentów,

Zakończ tę czynność, a także wszystkie czynności bezpośrednio pod nią w bieżącym zadaniu, które mają to samo podobieństwo. Jest to zwykle używane, gdy aplikacja może zostać uruchomiona w innym zadaniu (na przykład z ACTION_VIEW typu treści, który rozumie), a użytkownik wykorzystał nawigację w górę, aby przełączyć się z bieżącego zadania do własnego zadania. W takim przypadku, jeśli użytkownik przeszedł w dół do innych działań drugiej aplikacji, wszystkie z nich należy usunąć z pierwotnego zadania w ramach przełączania zadań. Zwróć uwagę, że to zakończenie nie pozwala na dostarczenie wyników do poprzedniego działania, a jeśli spróbujesz to zrobić, zostanie zgłoszony wyjątek.

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

spowoduje to wyczyszczenie zadania (stos działań) i rozpoczęcie nowego zadania

Intent intent = new Intent(Intent.ACTION_MAIN);
intent.addCategory(Intent.CATEGORY_HOME);
intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK);
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
startActivity(intent);
System.exit(1);

 @Override
    public void onBackPressed() {
        Intent homeIntent = new Intent(Intent.ACTION_MAIN);
        homeIntent.addCategory( Intent.CATEGORY_HOME );
        homeIntent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
        startActivity(homeIntent);
    }

umieść to w swoim onClic:

moveTaskToBack(true);
    finish()

Spróbuj tego podczas rozmowy. Czasami używam go po kliknięciu przycisku.

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

Zamiast zamykać aplikację, otwiera pulpit nawigacyjny, więc wygląda na to, że aplikacja jest zamknięta.

przeczytaj to pytanie, aby uzyskać większą jasność Android - kod aplikacji zakończony

Użyj this.finishAffinity (); na tym przycisku zamiast finish (); Jeśli to nie zadziała, możesz również spróbować, dodając android: noHistory = "true" w swoim manifeście, a następnie zakończyć działanie przez uisng finish (); lub finishAffinity ();

Mam nadzieję, że to pomoże....:)

Osiąganie w Xamarin.Android:

    public override void OnBackPressed()
    {
        MoveTaskToBack(true);
        Process.KillProcess(Process.MyPid());
        Environment.Exit(1);
    }

Po prostu wywołaj te dwie funkcje

 finish();
 moveTaskToBack(true);

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

Użyj tego kodu, który jest bardzo przydatny i możesz zakończyć wszystkie działania.

aktywność ducha wywoływana za pomocą singletop i finish () na onCreate powinna załatwić sprawę

Działa tylko przy użyciu moveTaskToBack(true);

Zamiast System.exit (1) Po prostu użyj System.exit (0)

Jeśli ktoś nadal się zastanawia, dla Xamarin.Android (w moim przypadku również uruchomionej na nim Monogame) polecenie FinishAndRemoveTask()on Activitywykonuje zadanie bardzo dobrze!

we fragmencie

getActivity (), finishAndRemoveTask ();

w działaniu

finishAndRemoveTask ();

po prostu użyj kodu w swoim backpressie

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

Jeśli używasz EventBus (lub naprawdę dowolnej innej biblioteki pub / sub) w swojej aplikacji do komunikacji między działaniami, możesz wysłać im jawne zdarzenie:

final public class KillItWithFireEvent
{
    public KillItWithFireEvent() {}

    public static void send()
    {
        EventBus.getDefault().post(new KillItWithFireEvent());
    }
}

Jedynym minusem jest to, że aby wysłuchać tego wydarzenia, potrzebujesz wszystkich działań, aby nazwać je własnymi finish(). W tym celu możesz łatwo utworzyć klasy aktywności shim poprzez dziedziczenie, które po prostu nasłuchują tego zdarzenia i pozwalają podklasom implementować wszystko inne, a następnie upewnij się, że wszystkie twoje działania dziedziczą z tej dodatkowej warstwy. Odbiorcy zabójstw mogą nawet dodać dodatkowe funkcje poprzez zastąpienia, takie jak unikanie śmierci w określonych sytuacjach.

Po prostu uruchom poniższe dwie linie, gdy chcesz wyjść z aplikacji

android.os.Process.killProcess(android.os.Process.myPid());
System.exit(1);

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

pracował dla mnie

Po prostu nazwij to:

finishAffinity();

Połącz tę metodę z przyciskiem wyjścia / wyjścia

public void quitGame(View view) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
            finishAndRemoveTask();
        } else {
            finish();
        }
    }

Jeśli użyjesz zarówno zakończenia, jak i wyjścia, aplikacja zostanie całkowicie zamknięta

koniec();

System.exit (0);