Comment fermer l'application Android?

Question

Je veux fermer mon application pour qu'elle ne s'exécute plus en arrière-plan.

Comment faire ça? Est-ce une bonne pratique sur la plateforme Android?

Si je me fie au bouton "retour", cela ferme l'application, mais elle reste en arrière-plan. Il y a même une application appelée "TaskKiller" juste pour tuer ces applications en arrière-plan.

Answer 1

Android a un mécanisme en place pour fermer une application en toute sécurité par sa documentation. Dans la dernière Activité qui est sorti (généralement la principale Activité est d'abord venu jusqu'au démarrage de l'application) il suffit de placer un couple de lignes dans le onDestroy() la méthode. L'appel Système.runFinalizersOnExit(vrai) s'assure que tous les objets seront finalisés et les ordures collectées lors de l'application se ferme. Vous pouvez aussi tuer une application rapidement via android.os.Processus.killProcess(android.os.Processus.myPid()) si vous préférez. La meilleure façon de le faire est de mettre une méthode comme celle-ci dans une classe d'assistance et ensuite l'appeler à chaque fois que l'application doit être tué. Par exemple, dans la méthode destroy de la racine de l'activité (en supposant que l'application ne tue jamais cette activité):

Android n'avisera pas une demande de la MAISON clé de l'événement, de sorte que vous ne pouvez pas fermer l'application lorsque la MAISON est enfoncée. Android se réserve le HOME clé de l'événement à lui-même, de sorte qu'un développeur ne peut pas empêcher les utilisateurs de quitter leur application. Cependant, vous pouvez déterminer à la MAISON une touche est pressée par un indicateur de vrai dans une classe d'assistance qui suppose que la MAISON de touche a été enfoncée, puis changer le drapeau de la valeur false lorsque se produit un événement qui montre la MAISON de la clé n'était pas pressé et puis de vérifier, pour voir de la MAISON enfoncée dans le onStop() la méthode de l'activité.

Ne pas oublier de traiter la MAISON clé pour tous les menus et dans les activités qui sont démarrés par les menus. Il en va de même pour la RECHERCHE de la clé. Ci-dessous est un exemple des classes pour illustrer:

Voici un exemple de la racine de l'activité qui tue l'application lorsqu'elle est détruite:

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

}

Voici un résumé de l'activité qui peut être étendue à gérer la MAISON de la clé de toutes les activités qui s'étendent:

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

Voici un exemple de l'écran du menu qui gère la MAISON de la clé:

/**
 * @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;
    }

}

Voici un exemple d'une classe d'assistance qui gère la MAISON de la clé dans l'application:

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

    }
}

Answer 2

OUI! Vous pouvez certainement fermer votre application de sorte qu'il est plus en cours d'exécution en arrière-plan. Comme d'autres l'ont fait remarquer finish() est le Google de la façon recommandée qui n'a pas vraiment dire que votre programme est fermé.

System.exit(0);

Que la droite, il y aura de fermer votre application ne laissant rien cours d'exécution en arrière-plan.Cependant,l'utiliser à bon escient et ne pas laisser l'ouverture des fichiers, base de données gère les ouvrir, etc.Ces choses devraient normalement être nettoyé par le biais de l' finish() commande.

Personnellement, je DÉTESTE lorsque je choisis de Quitter une application et il n'a pas vraiment de sortie.

Answer 3

Il s’agit de la façon dont je l’ai fait :

Je viens de mettre

à l’intérieur de la méthode qui ouvre une activité, puis à l’intérieur de la méthode de SOMECLASSNAME qui est conçu pour fermer l’application, que j’ai mis :

Et j’ai mis ce qui suit dans ma classe principale :

Answer 4

Juste pour répondre à ma propre question, maintenant, après tant de temps (depuis CommonsWare commenté la réponse la plus populaire dire que nous ne devrions PAS le faire):

Quand je veux quitter l'application:

1. Je commence ma première activité (écran de démarrage, ou quelle que soit l'activité est actuellement à la fin de l'activité de la pile) avec FLAG_ACTIVITY_CLEAR_TOP (qui va fermer toutes les autres activités ont commencé après elle, ce qui signifie - tous d'entre eux). Juste d'avoir cette activité dans l'activité de la pile (à ne pas en finir pour une raison quelconque à l'avance).
2. J'appelle finish() sur cette activité

C'est elle, fonctionne très bien pour moi.

Answer 5

Il suffit d’écrire ce code sur votre sortie, cliquez sur le bouton.

Et dans la méthode onCreate() de votre MainActivity.class écrivez ci-dessous le code comme une première ligne,