Comment fermer l'application Android?

Je souhaite 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 plate-forme Android?

Si je compte sur le bouton "retour", cela ferme l'application, mais il reste en arrière-plan. Il existe même une application appelée "TaskKiller" juste pour tuer ces applications en arrière-plan.

Android a un mécanisme en place pour fermer une application en toute sécurité conformément à sa documentation. Dans la dernière activité qui est quittée (généralement l'activité principale qui est apparue pour la première fois lorsque l'application a démarré), placez simplement quelques lignes dans la méthode onDestroy (). L'appel à System.runFinalizersOnExit (true) garantit que tous les objets seront finalisés et récupérés lors de la fermeture de l'application. Vous pouvez également tuer une application rapidement via android.os.Process.killProcess (android.os.Process.myPid ()) si vous préférez. La meilleure façon de le faire est de placer une méthode comme la suivante dans une classe d'assistance, puis de l'appeler chaque fois que l'application doit être tuée. Par exemple dans la méthode destroy de l'activité racine (en supposant que l'application ne tue jamais cette activité):

De plus, Android ne notifiera pas à une application l' événement de la touche HOME , vous ne pouvez donc pas fermer l'application lorsque la touche HOME est enfoncée. Android se réserve l' événement de clé HOME afin qu'un développeur ne puisse pas empêcher les utilisateurs de quitter leur application. Cependant, vous pouvez déterminer que la touche HOME est enfoncée en définissant un indicateur sur true dans une classe d'assistance qui suppose que la touche HOME a été enfoncée, puis en changeant l'indicateur en false lorsqu'un événement se produit qui montre que la touche HOME n'a pas été enfoncée, puis vérification de la présence de la touche HOME enfoncée dans la méthode onStop () de l'activité.

N'oubliez pas de manipuler la touche HOME pour tous les menus et dans les activités qui sont lancées par les menus. Il en va de même pour la touche RECHERCHE . Voici quelques exemples de classes pour illustrer:

Voici un exemple d'activité racine 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 une activité abstraite qui peut être étendue pour gérer la clé HOME pour toutes les activités qui l'é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 d'écran de menu qui gère la touche 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;
    }

}

Voici un exemple de classe d'assistance qui gère la clé HOME 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());
        }

    }
}

OUI! Vous pouvez très certainement fermer votre application pour qu'elle ne fonctionne plus en arrière-plan. Comme d'autres l'ont fait remarquer, finish()la méthode recommandée par Google ne signifie pas vraiment que votre programme est fermé.

System.exit(0);

Ce droit là fermera votre application en laissant rien en arrière-plan.Cependant, utilisez-le à bon escient et ne laissez pas les fichiers ouverts, les poignées de base de données ouvertes, etc.Ces choses seraient normalement nettoyées via la finish()commande.

Personnellement, je déteste quand je choisis Quitter dans une application et que cela ne se ferme pas vraiment.

Voici comment je l'ai fait:

Je viens de mettre

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

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

setResult(0);
finish();

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

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

Juste pour répondre à ma propre question maintenant après tant de temps (puisque CommonsWare a commenté la réponse la plus populaire disant que nous ne devrions PAS faire cela):

Lorsque je veux quitter l'application:

1. Je commence ma première activité (soit l'écran de démarrage, soit toute autre activité qui se trouve actuellement en bas de la pile d'activités) avec FLAG_ACTIVITY_CLEAR_TOP(qui quittera toutes les autres activités commencées après, ce qui signifie - toutes). Faites simplement pour avoir cette activité dans la pile d'activités (ne pas la terminer pour une raison quelconque à l'avance).
2. J'appelle finish()cette activité

Ça y est, ça marche assez bien pour moi.

Écrivez simplement ce code sur votre bouton EXIT cliquez.

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

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

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

Ce n'est pas possible en utilisant les API du framework. C'est à la discrétion du système d'exploitation (Android) de décider quand un processus doit être supprimé ou rester en mémoire. C'est pour des raisons d'efficacité: si l'utilisateur décide de relancer l'application, alors elle est déjà là sans qu'elle doive être chargée en mémoire.

Donc non, ce n'est pas seulement découragé , c'est impossible de le faire.

Pour sortir des applications:

Voie 1:

appeler finish();et passer outre onDestroy();. Mettez le code suivant dans onDestroy():

System.runFinalizersOnExit(true)

ou

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

Voie 2:

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

Voie 3:

Quit();

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

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

Voie 5:

Parfois, l'appel finish()ne quittera que l'activité en cours, pas l'ensemble de l'application. Cependant, il existe une solution de contournement pour cela. Chaque fois que vous démarrez un activity, démarrez-le en utilisant startActivityForResult(). Lorsque vous souhaitez fermer l'ensemble de l'application, vous pouvez faire quelque chose comme ceci:

setResult(RESULT_CLOSE_ALL);
finish();

Ensuite, définissez le onActivityResult(...)rappel de chaque activité afin que lorsqu'un activityretour avec la RESULT_CLOSE_ALLvaleur, il appelle également 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);
}

C'est ainsi que Windows Mobile a fonctionné depuis ... eh bien ... jamais! Voici ce que Microsoft a à dire à ce sujet:

http://blogs.msdn.com/windowsmobile/archive/2006/10/05/The-Emperor-Has-No-Close.aspx (est-ce triste que je me souvienne du titre du billet de blog depuis 2006? J'ai trouvé l'article sur Google en cherchant "l'empereur n'a pas de proche" lol)

En bref:

Si le système a besoin de plus de mémoire alors que l'application est en arrière-plan, il fermera l'application. Mais, si le système n'a pas besoin de plus de mémoire, l'application restera dans la RAM et sera prête à revenir rapidement la prochaine fois que l'utilisateur en aura besoin.

De nombreux commentaires dans cette question à O'Reilly suggèrent qu'Android se comporte à peu près de la même manière, fermant les applications qui n'ont pas été utilisées depuis un certain temps uniquement lorsque Android a besoin de la mémoire qu'elles utilisent.

Puisqu'il s'agit d'une fonctionnalité standard, changer le comportement pour fermer avec force changerait l'expérience utilisateur. De nombreux utilisateurs seraient habitués au rejet en douceur de leurs applications Android.Ainsi, lorsqu'ils en rejettent une avec l'intention d'y revenir après avoir effectué d'autres tâches, ils peuvent être plutôt frustrés que l'état de l'application soit réinitialisé ou que cela prenne plus de temps. ouvrir. Je m'en tiendrai au comportement standard car c'est ce à quoi on s'attend.

L'appel de la finish()méthode sur une activité a l'effet souhaité sur cette activité en cours.

aucune de toutes les réponses ci-dessus ne fonctionne bien sur mon application

voici mon code de travail

sur votre bouton de sortie:

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

ce code doit fermer toute autre activité et mettre MainActivity au sommet maintenant sur votre MainActivity:

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

Mettez une finish();déclaration comme ci-dessous:

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

finish();

LoginActivity.this.startActivity(myIntent);

Dans chaque activité.

@Override
    protected void onPause() {

        super.onPause();

        System.exit(0);

    }

Copiez le code ci-dessous et collez le fichier AndroidManifest.xml sous Première balise d'activité.

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

Ajoutez également ce code ci-dessous dans tout sous Activity Tag dans le fichier AndroidManifest.xml

 android:finishOnTaskLaunch="true"

Pas possible avec 2.3. Je recherche beaucoup et j'ai essayé de nombreuses applications. La meilleure solution consiste à installer à la fois (go taskmanager) et (fast reboot). Lorsque vous les utilisez ensemble, cela fonctionnera et libèrera la mémoire. Une autre option consiste à passer à Android Ice Cream Sandwich 4.0.4 qui permet de contrôler (fermer) les applications.

Je voulais revenir à l'écran d'accueil de mon appareil Android, j'ai donc simplement utilisé:

moveTaskToBack(true);

L'utilisation de finishAffinity()peut être une bonne option si vous souhaitez fermer toutes les activités de l'application. Selon les documents Android-

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

et en manifeste:

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

Ensuite, vous pouvez appeler CloseAppActivity.closeApp(fromActivity)et l'application sera fermée.

Écrivez simplement le code suivant dans 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();
}

en appelant finish (); dans le bouton OnClick ou dans le menu

case R.id.menu_settings:

      finish();
     return true;

Je pense que cela fermera votre activité et toutes les sous-activités qui y sont liées.

public boolean onOptionsItemSelected(MenuItem item) {

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

        return super.onOptionsItemSelected(item);
    }

Le moyen le meilleur et le plus court d'utiliser la table System.exit.

System.exit(0);

La VM arrête toute exécution et le programme se ferme.

Utilisez " this.FinishAndRemoveTask();" - il ferme correctement l'application