Jak zamknąć aplikację na Androida?

Chcę zamknąć moją aplikację, aby nie działała już w tle.

Jak to zrobić? Czy to dobra praktyka na platformie Android?

Jeśli korzystam z przycisku „Wstecz”, zamyka aplikację, ale pozostaje w tle. Istnieje nawet aplikacja o nazwie „TaskKiller”, która służy do zabijania tych aplikacji w tle.

Android ma mechanizm bezpiecznego zamykania aplikacji zgodnie z dokumentacją. W ostatnim działaniu, które zostało zakończone (zwykle jest to główne działanie, które pojawiło się po raz pierwszy podczas uruchamiania aplikacji), wystarczy umieścić kilka wierszy w metodzie onDestroy (). Wywołanie System.runFinalizersOnExit (true) zapewnia, że ​​wszystkie obiekty zostaną sfinalizowane i usunięte zostaną elementy bezużyteczne po zamknięciu aplikacji. Możesz także szybko zabić aplikację za pomocą android.os.Process.killProcess (android.os.Process.myPid ()) Jeśli wolisz, . Najlepszym sposobem na to jest umieszczenie metody takiej jak poniższa w klasie pomocniczej, a następnie wywołanie jej, gdy aplikacja musi zostać zabita. Na przykład w metodzie niszczenia działania roota (zakładając, że aplikacja nigdy nie zabije tej aktywności):

Ponadto system Android nie powiadomi aplikacji o zdarzeniu klawisza HOME , więc nie można zamknąć aplikacji po naciśnięciu klawisza HOME . Android rezerwuje zdarzenie klucza HOME dla siebie, aby programista nie mógł uniemożliwić użytkownikom opuszczenia aplikacji. Można jednak stwierdzić, że naciśnięto klawisz HOME, ustawiając flagę na true w klasie pomocniczej, która zakłada, że klawisz HOME został naciśnięty, a następnie zmieniając flagę na false, gdy wystąpi zdarzenie, które pokazuje, że klawisz HOME nie został naciśnięty, a następnie sprawdzenie, czy klawisz HOME został naciśnięty w metodzie onStop () aktywności.

Nie zapomnij posługiwać się klawiszem HOME dla wszystkich menu i czynności uruchamianych przez menu. To samo dotyczy klawisza SEARCH . Poniżej znajduje się kilka przykładowych klas do zilustrowania:

Oto przykład działania roota, które zabija aplikację po jej zniszczeniu:

package android.example;

/**
 * @author Danny Remington - MacroSolve
 */

public class HomeKey extends CustomActivity {

    public void onDestroy() {
        super.onDestroy();

        /*
         * Kill application when the root activity is killed.
         */
        UIHelper.killApp(true);
    }

}

Oto abstrakcyjne działanie, które można rozszerzyć tak, aby obsługiwało klucz HOME dla wszystkich działań, które go rozszerzają:

package android.example;

/**
 * @author Danny Remington - MacroSolve
 */

import android.app.Activity;
import android.view.Menu;
import android.view.MenuInflater;

/**
 * Activity that includes custom behavior shared across the application. For
 * example, bringing up a menu with the settings icon when the menu button is
 * pressed by the user and then starting the settings activity when the user
 * clicks on the settings icon.
 */
public abstract class CustomActivity extends Activity {
    public void onStart() {
        super.onStart();

        /*
         * Check if the app was just launched. If the app was just launched then
         * assume that the HOME key will be pressed next unless a navigation
         * event by the user or the app occurs. Otherwise the user or the app
         * navigated to this activity so the HOME key was not pressed.
         */

        UIHelper.checkJustLaunced();
    }

    public void finish() {
        /*
         * This can only invoked by the user or the app finishing the activity
         * by navigating from the activity so the HOME key was not pressed.
         */
        UIHelper.homeKeyPressed = false;
        super.finish();
    }

    public void onStop() {
        super.onStop();

        /*
         * Check if the HOME key was pressed. If the HOME key was pressed then
         * the app will be killed. Otherwise the user or the app is navigating
         * away from this activity so assume that the HOME key will be pressed
         * next unless a navigation event by the user or the app occurs.
         */
        UIHelper.checkHomeKeyPressed(true);
    }

    public boolean onCreateOptionsMenu(Menu menu) {
        MenuInflater inflater = getMenuInflater();
        inflater.inflate(R.menu.settings_menu, menu);

        /*
         * Assume that the HOME key will be pressed next unless a navigation
         * event by the user or the app occurs.
         */
        UIHelper.homeKeyPressed = true;

        return true;
    }

    public boolean onSearchRequested() {
        /*
         * Disable the SEARCH key.
         */
        return false;
    }
}

Oto przykład ekranu menu, który obsługuje klawisz HOME :

/**
 * @author Danny Remington - MacroSolve
 */

package android.example;

import android.os.Bundle;
import android.preference.PreferenceActivity;

/**
 * PreferenceActivity for the settings screen.
 * 
 * @see PreferenceActivity
 * 
 */
public class SettingsScreen extends PreferenceActivity {
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        addPreferencesFromResource(R.layout.settings_screen);
    }

    public void onStart() {
        super.onStart();

        /*
         * This can only invoked by the user or the app starting the activity by
         * navigating to the activity so the HOME key was not pressed.
         */
        UIHelper.homeKeyPressed = false;
    }

    public void finish() {
        /*
         * This can only invoked by the user or the app finishing the activity
         * by navigating from the activity so the HOME key was not pressed.
         */
        UIHelper.homeKeyPressed = false;
        super.finish();
    }

    public void onStop() {
        super.onStop();

        /*
         * Check if the HOME key was pressed. If the HOME key was pressed then
         * the app will be killed either safely or quickly. Otherwise the user
         * or the app is navigating away from the activity so assume that the
         * HOME key will be pressed next unless a navigation event by the user
         * or the app occurs.
         */
        UIHelper.checkHomeKeyPressed(true);
    }

    public boolean onSearchRequested() {
        /*
         * Disable the SEARCH key.
         */
        return false;
    }

}

Oto przykład klasy pomocniczej, która obsługuje klawisz HOME w aplikacji:

package android.example;

/**
 * @author Danny Remington - MacroSolve
 *
 */

/**
 * Helper class to help handling of UI.
 */
public class UIHelper {
    public static boolean homeKeyPressed;
    private static boolean justLaunched = true;

    /**
     * Check if the app was just launched. If the app was just launched then
     * assume that the HOME key will be pressed next unless a navigation event
     * by the user or the app occurs. Otherwise the user or the app navigated to
     * the activity so the HOME key was not pressed.
     */
    public static void checkJustLaunced() {
        if (justLaunched) {
            homeKeyPressed = true;
            justLaunched = false;
        } else {
            homeKeyPressed = false;
        }
    }

    /**
     * Check if the HOME key was pressed. If the HOME key was pressed then the
     * app will be killed either safely or quickly. Otherwise the user or the
     * app is navigating away from the activity so assume that the HOME key will
     * be pressed next unless a navigation event by the user or the app occurs.
     * 
     * @param killSafely
     *            Primitive boolean which indicates whether the app should be
     *            killed safely or quickly when the HOME key is pressed.
     * 
     * @see {@link UIHelper.killApp}
     */
    public static void checkHomeKeyPressed(boolean killSafely) {
        if (homeKeyPressed) {
            killApp(true);
        } else {
            homeKeyPressed = true;
        }
    }

    /**
     * Kill the app either safely or quickly. The app is killed safely by
     * killing the virtual machine that the app runs in after finalizing all
     * {@link Object}s created by the app. The app is killed quickly by abruptly
     * killing the process that the virtual machine that runs the app runs in
     * without finalizing all {@link Object}s created by the app. Whether the
     * app is killed safely or quickly the app will be completely created as a
     * new app in a new virtual machine running in a new process if the user
     * starts the app again.
     * 
     * <P>
     * <B>NOTE:</B> The app will not be killed until all of its threads have
     * closed if it is killed safely.
     * </P>
     * 
     * <P>
     * <B>NOTE:</B> All threads running under the process will be abruptly
     * killed when the app is killed quickly. This can lead to various issues
     * related to threading. For example, if one of those threads was making
     * multiple related changes to the database, then it may have committed some
     * of those changes but not all of those changes when it was abruptly
     * killed.
     * </P>
     * 
     * @param killSafely
     *            Primitive boolean which indicates whether the app should be
     *            killed safely or quickly. If true then the app will be killed
     *            safely. Otherwise it will be killed quickly.
     */
    public static void killApp(boolean killSafely) {
        if (killSafely) {
            /*
             * Notify the system to finalize and collect all objects of the app
             * on exit so that the virtual machine running the app can be killed
             * by the system without causing issues. NOTE: If this is set to
             * true then the virtual machine will not be killed until all of its
             * threads have closed.
             */
            System.runFinalizersOnExit(true);

            /*
             * Force the system to close the app down completely instead of
             * retaining it in the background. The virtual machine that runs the
             * app will be killed. The app will be completely created as a new
             * app in a new virtual machine running in a new process if the user
             * starts the app again.
             */
            System.exit(0);
        } else {
            /*
             * Alternatively the process that runs the virtual machine could be
             * abruptly killed. This is the quickest way to remove the app from
             * the device but it could cause problems since resources will not
             * be finalized first. For example, all threads running under the
             * process will be abruptly killed when the process is abruptly
             * killed. If one of those threads was making multiple related
             * changes to the database, then it may have committed some of those
             * changes but not all of those changes when it was abruptly killed.
             */
            android.os.Process.killProcess(android.os.Process.myPid());
        }

    }
}

TAK! Z całą pewnością możesz zamknąć aplikację, aby nie działała już w tle. Tak jak inni skomentowali, finish()jest zalecany przez Google sposób, który tak naprawdę nie oznacza, że ​​twój program jest zamknięty.

System.exit(0);

To właśnie tam zamknie twoją aplikację, nie pozostawiając niczego działającego w tle, jednak używaj tego mądrze i nie zostawiaj otwartych plików, otwartych uchwytów bazy danych itp. Te rzeczy normalnie zostałyby wyczyszczone za pomocą finish()polecenia.

Osobiście NIENAWIDZĘ, gdy wybieram opcję Zakończ w aplikacji i tak naprawdę nie wychodzi.

Tak to zrobiłem:

Po prostu włożyłem

Intent intent = new Intent(Main.this, SOMECLASSNAME.class);
Main.this.startActivityForResult(intent, 0);

wewnątrz metody, która otwiera działanie, a następnie wewnątrz metody SOMECLASSNAME, która ma na celu zamknięcie aplikacji, którą umieściłem:

setResult(0);
finish();

W mojej klasie głównej umieściłem:

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    if(resultCode == 0) {
        finish();
    }
}

Wystarczy, że po tak długim czasie odpowiem na moje własne pytanie (ponieważ CommonsWare skomentował najpopularniejszą odpowiedź, mówiąc, że NIE powinniśmy tego robić):

Kiedy chcę zamknąć aplikację:

1. Rozpoczynam moją pierwszą aktywność (ekran powitalny lub jakakolwiek FLAG_ACTIVITY_CLEAR_TOPinna czynność aktualnie znajdująca się na dole stosu aktywności) z (co spowoduje zakończenie wszystkich innych czynności rozpoczętych po niej, co oznacza - wszystkie). Po prostu spraw, aby ta aktywność była na stosie aktywności (nie kończ jej z jakiegoś powodu z góry).
2. Wzywam finish()tę aktywność

To jest to, na mnie działa całkiem nieźle.

Po prostu napisz ten kod na swoim przycisku EXIT kliknij.

Intent intent = new Intent(getApplicationContext(), MainActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
intent.putExtra("LOGOUT", true);
startActivity(intent);

A w metodzie onCreate () Twojego MainActivity.class napisz poniższy kod jako pierwszą linię,

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

Nie jest to możliwe przy użyciu interfejsów API platformy. To system operacyjny (Android) decyduje, kiedy proces powinien zostać usunięty lub pozostawiony w pamięci. Dzieje się tak ze względu na wydajność: jeśli użytkownik zdecyduje się ponownie uruchomić aplikację, to już tam jest, bez konieczności ładowania jej do pamięci.

Więc nie, nie tylko jest to zniechęcone , ale nie można tego zrobić.

Wychodzenie z aplikacji:

Sposób 1:

zadzwoń finish();i zastąp onDestroy();. Umieść następujący kod w onDestroy():

System.runFinalizersOnExit(true)

lub

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

Sposób 2:

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

Sposób 3:

Quit();

protected void Quit() {
    super.finish();
}

Sposób 4:

Intent intent = new Intent(getApplicationContext(), LoginActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
intent.putExtra("EXIT", true);
startActivity(intent);

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

Sposób 5:

Czasami wywołanie finish()kończy tylko bieżącą czynność, a nie całą aplikację. Istnieje jednak obejście tego problemu. Za każdym razem, gdy zaczynasz activity, zacznij od startActivityForResult(). Jeśli chcesz zamknąć całą aplikację, możesz wykonać następujące czynności:

setResult(RESULT_CLOSE_ALL);
finish();

Następnie zdefiniuj onActivityResult(...)wywołanie zwrotne każdego działania, więc gdy activityzwraca RESULT_CLOSE_ALLwartość, wywołuje również finish():

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    switch(resultCode){
        case RESULT_CLOSE_ALL:{
            setResult(RESULT_CLOSE_ALL);
            finish();
        }
    }
    super.onActivityResult(requestCode, resultCode, data);
}

W ten sposób system Windows Mobile działał ... cóż ... zawsze! Oto, co Microsoft ma do powiedzenia w tej sprawie:

http://blogs.msdn.com/windowsmobile/archive/2006/10/05/The-Emperor-Has-No-Close.aspx (czy to smutne, że przypomniałem sobie tytuł wpisu na blogu z 2006 roku? Znalazłem artykuł w Google, wyszukując „cesarz nie ma bliskiego” lol)

W skrócie:

Jeśli system potrzebuje więcej pamięci, gdy aplikacja działa w tle, zamknie aplikację. Ale jeśli system nie potrzebuje więcej pamięci, aplikacja pozostanie w pamięci RAM i będzie gotowa do szybkiego powrotu, gdy następnym razem będzie jej potrzebować.

Wiele komentarzy w tym pytaniu w O'Reilly sugeruje, że Android zachowuje się w podobny sposób, zamykając aplikacje, które nie były używane przez jakiś czas, tylko wtedy, gdy Android potrzebuje pamięci, której używa.

Ponieważ jest to funkcja standardowa, zmiana zachowania na wymuszone zamknięcie spowodowałaby zmianę doświadczenia użytkownika. Wielu użytkowników byłoby przyzwyczajonych do łagodnego odrzucania aplikacji na Androida, więc kiedy odrzucają jedną z nich z zamiarem powrotu do niej po wykonaniu innych zadań, mogą być raczej sfrustrowani, że stan aplikacji jest resetowany lub że trwa to dłużej otworzyć. Trzymałbym się standardowego zachowania, ponieważ tego się oczekuje.

Wywołanie finish()metody w działaniu ma pożądany wpływ na bieżące działanie.

żadna z powyższych odpowiedzi nie działa dobrze w mojej aplikacji

oto mój działający kod

na przycisku wyjścia:

Intent intent = new Intent(getApplicationContext(), MainActivity.class);
ComponentName cn = intent.getComponent();
Intent mainIntent = IntentCompat.makeRestartActivityTask(cn);
mainIntent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_NEW_TASK);
mainIntent.addFlags(Intent.FLAG_ACTIVITY_NO_HISTORY);
mainIntent.putExtra("close", true);
startActivity(mainIntent);
finish();

ten kod ma na celu zamknięcie wszelkich innych działań i przeniesienie MainActivity na wierzch teraz w Twojej MainActivity:

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

Umieść finish();oświadczenie jak poniżej:

myIntent.putExtra("key1", editText2.getText().toString());

finish();

LoginActivity.this.startActivity(myIntent);

W każdej czynności.

@Override
    protected void onPause() {

        super.onPause();

        System.exit(0);

    }

Skopiuj poniższy kod i wklej plik AndroidManifest.xml w obszarze First Activity Tag.

<activity                        
            android:name="com.SplashActivity"
            android:clearTaskOnLaunch="true" 
            android:launchMode="singleTask"
            android:excludeFromRecents="true">              
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER"
                />
            </intent-filter>
        </activity>     

Dodaj również poniższy kod we wszystkich w obszarze Activity Tag w pliku AndroidManifest.xml

 android:finishOnTaskLaunch="true"

Niemożliwe z 2.3. Dużo przeszukuję i wypróbowałem wiele aplikacji. Najlepszym rozwiązaniem jest zainstalowanie zarówno (go taskmanager), jak i (szybkiego ponownego uruchomienia). Używając ich razem, zadziała i uwolni pamięć. Inną opcją jest aktualizacja do Android Ice Cream Sandwich 4.0.4, która umożliwia kontrolę (zamknięcie) aplikacji.

Chciałem wrócić do ekranu głównego mojego urządzenia z Androidem, więc po prostu użyłem:

moveTaskToBack(true);

Użycie finishAffinity()może być dobrą opcją, jeśli chcesz zamknąć całą aktywność aplikacji. Zgodnie z dokumentami Androida

Finish this activity as well as all activities immediately below it in the current task that have the same affinity.

public class CloseAppActivity extends AppCompatActivity
{
    public static final void closeApp(Activity activity)
    {
        Intent intent = new Intent(activity, CloseAppActivity.class);
        intent.addCategory(Intent.CATEGORY_HOME);
        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK |
                IntentCompat.FLAG_ACTIVITY_CLEAR_TASK);
        activity.startActivity(intent);
    }

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

i wyraźnie:

<activity
     android:name=".presenter.activity.CloseAppActivity"
     android:noHistory="true"
     android:clearTaskOnLaunch="true"/>

Wtedy możesz zadzwonić CloseAppActivity.closeApp(fromActivity)i aplikacja zostanie zamknięta.

Po prostu napisz następujący kod w onBackPressed:

@Override
public void onBackPressed() {
    // super.onBackPressed();

    //Creating an alert dialog to logout
    AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(this);
    alertDialogBuilder.setMessage("Do you want to Exit?");
    alertDialogBuilder.setPositiveButton("Yes",
            new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface arg0, int arg1) {
                    Intent intent = new Intent(Intent.ACTION_MAIN);
                    intent.addCategory(Intent.CATEGORY_HOME);
                    startActivity(intent);
                }
            });

    alertDialogBuilder.setNegativeButton("No",
            new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface arg0, int arg1) {

                }
            });

    //Showing the alert dialog
    AlertDialog alertDialog = alertDialogBuilder.create();
    alertDialog.show();
}

wywołując finish (); w przycisku OnClick lub w menu

sprawa R.id.menu_settings:

      finish();
     return true;

Myślę, że spowoduje to zamknięcie Twojej działalności i wszystkich powiązanych z nią działań podrzędnych.

public boolean onOptionsItemSelected(MenuItem item) {

        int id = item.getItemId();]
        if (id == R.id.Exit) {
            this.finishAffinity();
            return true;
        }

        return super.onOptionsItemSelected(item);
    }

Najlepszy i najkrótszy sposób korzystania z tabeli System.exit.

System.exit(0);

Maszyna wirtualna zatrzymuje dalsze wykonywanie i program kończy pracę.

Użyj „ this.FinishAndRemoveTask();” - poprawnie zamyka aplikację