Comment quitter l'application android par programme


Answers

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

C'est la meilleure façon de quitter votre application.

La meilleure solution pour moi.

Question

J'ai trouvé des codes pour quitter une application Android par programmation. 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. Pls me suggère que je peux utiliser 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?




Ce n'est pas une bonne décision, parce que c'est contre les principes de traitement des applications Android. Android ne tue aucun processus sauf si c'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.




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

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

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



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



La façon la plus simple de quitter une application à partir d'une activité, sans enfreindre la logique d'Android et sans ajouter de code dans les activités existantes et les extras de passage, est la suivante:

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

le QuitApplicationActivity étant:

public class QuitApplicationActivity extends AppCompatActivity {

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

        finish ();
    }
}



Aucune application ne s'arrête dans android , SampleActivity.this.finish (); terminera l'activité en cours.

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

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



finishAffinity();

System.exit(0);

Si vous utiliserez seulement finishAffinity(); sans System.exit(0); votre application va quitter mais la mémoire allouée sera toujours utilisée par votre téléphone, donc ... si vous voulez une application propre et vraiment fermée, utilisez les deux.

C'est la méthode la plus simple et fonctionne n'importe où, quittez l'application pour de vrai, vous pouvez avoir beaucoup d'activité ouverte encore tout quitter 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 gentil, exemple avec un 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();



Cela va tuer n'importe quoi;)

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



Je ne sais pas si c'est mal vu ou pas, 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 à l'intérieur de la classe pour chaque activité de votre application. Créez ensuite une méthode statique appelée "close" qui exécutera la méthode finish() sur chacune de ces variables d'activité si elles ne sont pas NULL . 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 onStart() et onDestroy() . Dans onStart() , définissez la variable statique de votre classe App égale à " this ". Dans onDestroy() , définissez-le égal à 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 App.close() depuis n'importe où. Toutes les activités instanciées vont se fermer! Puisque vous ne faites que fermer des activités et ne pas tuer l'application elle-même (comme dans vos exemples), Android est libre de prendre le relais à partir de là et de faire 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 les commentaires sur pourquoi c'est et comment il peut être amélioré!




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

// On Button Back événement pressé

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



Utilisez simplement finish () sur la touche back appuyez sur onKeypressed ()




Links