Comment quitter une application Android par programme

J'ai trouvé quelques codes pour quitter une application Android par programme. En appelant l'un des codes suivants dans onDestroy (), quittera-t-il complètement l'application?

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

Je ne veux pas exécuter mon application en arrière-plan après avoir cliqué sur le bouton Quitter. Veuillez me suggérer, puis-je utiliser l'un de ces codes pour quitter mon application? Si oui, quel code puis-je utiliser? Est-ce un bon moyen de quitter l'application sur Android?

Depuis l'API 16, vous pouvez utiliser la méthode finishAffinity, qui semble assez proche de la fermeture de toutes les activités associées par son nom et sa description Javadoc:

this.finishAffinity();

Terminez cette activité ainsi que toutes les activités immédiatement en dessous dans la tâche en cours qui ont la même affinité. Ceci est généralement utilisé lorsqu'une application peut être lancée sur une autre tâche (telle qu'une ACTION_VIEW d'un type de contenu qu'il comprend) et que l'utilisateur a utilisé la navigation vers le haut pour passer de la tâche en cours à sa propre tâche. Dans ce cas, si l'utilisateur a accédé à d'autres activités de la deuxième application, toutes ces activités doivent être supprimées de la tâche d'origine dans le cadre du changement de tâche.

Notez que cette finition ne vous permet pas de fournir des résultats à l'activité précédente et une exception sera levée si vous essayez de le faire.

Depuis l'API 21, vous pouvez utiliser une commande très similaire

finishAndRemoveTask();

Termine toutes les activités de cette tâche et la supprime de la liste des tâches récentes.

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

c'est le meilleur moyen de quitter votre application. !!!

La meilleure solution pour moi.

finishAffinity();

System.exit(0);

Si vous n'utilisez que finishAffinity();sans que System.exit(0);votre application se ferme mais que la mémoire allouée sera toujours utilisée par votre téléphone, alors ... si vous voulez une application propre et vraiment quitter, utilisez les deux.

Ceci est la méthode la plus simple et fonctionne n'importe où, quittez l'application pour de vrai, vous pouvez avoir beaucoup d'activités ouvertes tout en quittant sans problème.

exemple sur un clic de bouton

public void exitAppCLICK (View view) {

    finishAffinity();
    System.exit(0);

}

ou si vous voulez quelque chose de sympa, exemple avec une boîte de dialogue d'alerte avec 3 boutons OUI NON et ANNULER

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

Réfléchissez bien si vous devez tuer l'application: pourquoi ne pas laisser le système d'exploitation déterminer où et quand libérer les ressources?

Sinon, si vous êtes absolument sûr, utilisez

finish();

En réaction au commentaire de @dave appleton: Tout d'abord, lisez le grand combo questions / réponses @gabriel publié: La fermeture d' une application est-elle mal vue?

En supposant maintenant que nous l'avons, la question ici a toujours une réponse, à savoir que le code dont vous avez besoin si vous faites quoi que ce soit avec l'arrêt est finish(). De toute évidence, vous pouvez avoir plus d'une activité, etc., etc., mais ce n'est pas le but. Permet d'exécuter certains des cas d'utilisation

1. Vous voulez laisser l'utilisateur quitter tout à cause de l'utilisation de la mémoire et "ne pas s'exécuter en arrière-plan? Douteux. Laissez l'utilisateur arrêter certaines activités en arrière-plan, mais laissez le système d'exploitation tuer tous les recours inutiles.
2. Vous souhaitez qu'un utilisateur ne passe pas à l'activité précédente de votre application? Eh bien, configurez-le pour que ce ne soit pas le cas, ou vous avez besoin d'une option supplémentaire. Si la plupart du temps, l'activité back = previous fonctionne, l'utilisateur ne presserait-il pas simplement à la maison s'il souhaite faire autre chose?
3. Si vous avez besoin d'une réinitialisation, vous pouvez savoir si / comment / etc votre application a été arrêtée, et si votre activité se concentre à nouveau, vous pouvez prendre des mesures à ce sujet, en affichant un nouvel écran au lieu de redémarrer où vous étiez.

Donc en fin de compte, bien sûr, finish()ne tue pas tout, mais c'est toujours l'outil dont vous avez besoin, je pense. S'il existe un cas d'utilisation pour "tuer toutes les activités", je ne l'ai pas encore trouvé.

Je pense que cette application devrait être tuée dans certains cas. Par exemple, une application ne peut être utilisée qu'après la connexion. L'activité de connexion comporte deux boutons, «connexion» et «annuler». Lorsque vous cliquez sur le bouton «Annuler», cela signifie définitivement «Terminer l'application». Personne ne veut que l'application vive en arrière-plan. Je suis donc d'accord que certains cas doivent fermer l'application.

Créez un ExitActivityet déclarez-le dans le manifeste. Et appelez ExitActivity.exit(context)à quitter l'application.

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

}

Il n'y a pas d'application quittant Android , SampleActivity.this.finish (); terminera l'activité en cours.

Lorsque vous passez d'une activité à une autre, continuez de terminer la précédente

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

Tout d'abord, cette approche nécessite min Api 16.

Je diviserai cette solution en 3 parties pour résoudre ce problème plus largement.

1. Si vous souhaitez quitter l'application dans une activité, utilisez cet extrait de code:

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

2. Si vous souhaitez quitter l'application dans une classe non Activity qui a accès à Activity, utilisez cet extrait de code:

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

3. Si vous souhaitez quitter l'application dans une classe non Activity et ne pouvez pas accéder à Activity tel que Service, je vous recommande d'utiliser BroadcastReceiver. Vous pouvez ajouter cette approche à toutes vos activités dans votre projet.

Créez des variables d'instance LocalBroadcastManager et BroadcastReceiver. Vous pouvez remplacer getPackageName () + ". Closeapp" si vous le souhaitez.

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

Ajoutez-les à la méthode d'activité onCreate ().

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

N'oubliez pas non plus d'appeler unregister receiver à la méthode d'activité onDestroy ()

mLocalBroadcastManager.unregisterReceiver(mBroadcastReceiver);

Pour quitter l'application, vous devez envoyer une diffusion à l'aide de LocalBroadcastManager que j'utilise dans ma classe PlayService qui étend le service.

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

Vous pouvez utiliser à finishAndRemoveTask ()partir de l'API 21

public void finishAndRemoveTask ()

Termine toutes les activités de cette tâche et la supprime de la liste des tâches récentes.

Cela dépend de la vitesse à laquelle vous souhaitez fermer votre application.

Un moyen sûr de fermer votre application est finishAffinity ();

Il ferme votre application une fois tous les processus terminés. Cela peut prendre un certain temps. Si vous fermez votre application de cette façon et la redémarrez après un court instant, il est possible que votre nouvelle application s'exécute dans le même processus. Avec tous les processus non terminés et les objets singleton de l'ancienne application.

Si vous voulez être sûr que votre application est complètement fermée, utilisez System.exit (0);

Cela fermera votre application immédiatement. Mais il est possible que vous endommagiez les fichiers ouverts par votre application ou que la modification des préférences partagées ne se termine pas. Alors utilisez-le soigneusement.

Si vous utilisez le chien de garde en combinaison avec une tâche de longue durée, vous pouvez voir les influences des différentes méthodes.

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

Cela tue votre application après 2 secondes sans afficher de boîte de dialogue ANR ou quelque chose comme ça. Si vous supprimez System.exit (0) , exécutez ce code et redémarrez l'application après sa fermeture, vous rencontrerez un comportement étrange, car la boucle sans fin est toujours en cours d'exécution.

Vous feriez mieux de l'utiliser finish()si vous êtes dans Activity, ou getActivity().finish()si vous êtes dans le Fragment.

Si vous souhaitez quitter complètement l'application, utilisez:

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

Un moyen facile et simple de quitter l'application

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

Nous voulons un code robuste et simple. Cette solution fonctionne sur les anciens appareils et les nouveaux appareils.

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

Je pense que ce que vous cherchez c'est

activity.moveTaskToBack(Boolean nonRoot);

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

Similaire à @MobileMateo, mais à Kotlin

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

Je ne sais pas si cela est mal vu ou non, mais c'est comme ça que je le fais ...

Étape 1 - J'ai généralement une classe qui contient des méthodes et des variables auxquelles je veux accéder globalement. Dans cet exemple, je l'appellerai la classe "App". Créez une variable d'activité statique dans la classe pour chaque activité de votre application. Créez ensuite une méthode statique appelée "close" qui exécutera la finish()méthode sur chacune de ces variables d'activité si elles ne sont PAS nulles . Si vous avez une activité principale / parent, fermez-la en dernier:

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

Étape 2 - dans chacune de vos activités, remplacez les méthodes onStart()et onDestroy(). Dans onStart(), définissez la variable statique de votre classe App sur " this". Dans onDestroy(), définissez-le sur null. Par exemple, dans la classe "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;
}

Étape 3 - Lorsque vous souhaitez fermer votre application, appelez simplement App.close()de n'importe où. Toutes les activités instanciées seront fermées! Étant donné que vous ne fermez que des activités et ne tuez pas l'application elle-même (comme dans vos exemples), Android est libre de prendre le relais et d'effectuer le nettoyage nécessaire.

Encore une fois, je ne sais pas si cela serait mal vu pour une raison quelconque. Si c'est le cas, j'aimerais lire des commentaires sur les raisons pour lesquelles cela est et comment il peut être amélioré!

Quitter une application est-il mal vu? . Passez par ce lien. Cela répond à votre question. Le système supprime une application.

Supposons que vous ayez deux activités A et B. Vous naviguez de A à B. Lorsque vous cliquez sur le bouton de retour, votre activité B est extraite du backstack et détruite. L'activité précédente dans l'activité de pile arrière A prend le focus.

Vous devez laisser au système le soin de décider quand tuer l'application.

vide public finish()

Appelez cela lorsque votre activité est terminée et doit être fermée.

Supposons que vous ayez de nombreuses activités. vous pouvez utiliser la barre d'action. Cliquez sur l'icône d'accueil pour naviguer vers MainActivity de votre application. Dans MainActivity, cliquez sur le bouton Retour pour quitter l'application.

Pour quitter votre application, vous pouvez utiliser les éléments suivants:

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

Pour arrêter également les services, appelez également la méthode suivante:

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

Cela peut être très tard et selon les directives, vous n'êtes pas censé gérer le processus du cycle de vie par vous-même (comme le système d'exploitation le fait pour vous). Une suggestion serait d'enregistrer un récepteur de diffusion dans toutes vos activités avec " finish()" dans leur onReceive() & chaque fois que vous souhaitez quitter, vous pouvez simplement transmettre une intention indiquant que toutes les activités doivent s'arrêter ..... Bien que assurez-vous que vous le faites " désenregistrer "le récepteur dans vos onDestroy()méthodes.

Ce n'est pas une bonne décision, car c'est contraire aux principes de traitement des applications d'Android. Android ne tue aucun processus sauf s'il est absolument inévitable. Cela permet aux applications de démarrer plus rapidement, car elles sont toujours conservées en mémoire. Vous avez donc besoin d'une raison très spéciale pour tuer le processus de votre application.

La solution correcte et exacte pour quitter l'application en cliquant sur le bouton utilise le code ci-dessous:

// Événement enfoncé On Button Back

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

Si vous utilisez Kotlin, la bonne façon de quitter l'application et l'alternative à System.exit()est une méthode intégrée

exitProcess(0)

Consultez la documentation .

Le nombre en 0tant que paramètre signifie que la sortie est prévue et qu'aucune erreur ne s'est produite.

Cela tuera n'importe quoi;)

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

Essaye ça

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

Le moyen le plus simple que j'ai trouvé pour quitter une application d'une activité, sans casser la logique d'Android et sans ajouter plus de code dans les activités existantes et en passant les extras est le suivant:

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

l' QuitApplicationActivityêtre:

public class QuitApplicationActivity extends AppCompatActivity {

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

        finish ();
    }
}

La réponse de @Sivi ferme l'application. Mais au retour, si vous avez des activités pour les enfants, une autre activité inachevée peut être ouverte. J'ai ajouté noHistory:trueà mes activités pour que l'application au retour commence à partir de MainActivity.

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

Juste pour en ajouter une à la liste des méthodes brutales de résiliation d'une application:

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

vous pouvez quitter vos applications complètes. Donc

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

cela fonctionnera à 100%. Bonne chance!

Utilisez simplement finish () sur la touche retour, appuyez sur la touche ()