Comment quitter une application Android par programme
J'ai trouvé des codes pour quitter une application Android par programmation. En appelant l’un des codes suivants dans onDestroy (), l’application quittera-t-elle entièrement?
System.runFinalizersOnExit(true)
(OU)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é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 sous Android?
Depuis l'API 16, vous pouvez utiliser la méthode finishAffinity, qui semble être sur le point de fermer 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 inférieures à celle-ci dans la tâche en cours ayant la même affinité. Cela est généralement utilisé lorsqu'une application peut être lancée sur une autre tâche (par exemple à partir d'un ACTION_VIEW d'un type de contenu qu'elle 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é à une autre activité de la deuxième application, toutes ces activités doivent être supprimées de la tâche d'origine dans le cadre du commutateur de tâches.
Notez que cette fin 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 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.
S'il vous plaît, 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: Première chose à lire la grande liste déroulante questions/réponses @gabriel posté: Est-ce que quitter une application est mal vu?
En supposant que cela soit le cas, la question posée reste toujours une réponse, à savoir que le code dont vous avez besoin pour cesser de fumer est finish(). Évidemment, vous pouvez avoir plusieurs activités, etc., mais ce n’est pas le but. Permet de gérer certains cas d'utilisation
- Vous voulez laisser l'utilisateur tout quitter à cause de l'utilisation de la mémoire et "ne pas s'exécuter en arrière-plan? Doubtfull. Laissez l'utilisateur arrêter certaines activités en arrière-plan, mais laissez le système d'exploitation supprimer tous les recours inutiles.
- Vous voulez qu'un utilisateur ne passe pas à l'activité précédente de votre application? Eh bien, configurez-le de manière à ne pas le faire ou vous avez besoin d’une option supplémentaire. Si la plupart du temps l'activité retour = précédente est active, l'utilisateur ne se contente-t-il pas d'appuyer sur le bouton s'il souhaite faire autre chose?
- Si vous avez besoin d'une sorte de réinitialisation, vous pouvez savoir si/comment/etc, votre application a été fermée et si votre activité redevient active, vous pouvez agir, afficher un nouvel écran au lieu de redémarrer à votre place.
Donc, à la fin, bien sûr, finish() ne tue pas tout, mais c'est toujours l'outil dont vous avez besoin, je pense. S'il existe un casus pour "tuer toutes les activités", je ne l'ai pas encore trouvé.
Je pense que cette application devrait être tuer dans certains cas. Par exemple, il existe une application qui ne peut être utilisée qu’après la connexion. L'activité de connexion comporte deux boutons, 'login' et 'cancel'. Lorsque vous cliquez sur le bouton 'Annuler', cela signifie certainement 'Terminez l'application'. Personne ne veut que l'application soit vivante en arrière-plan. Donc, je suis d'accord que certains cas doivent fermer l'application.
Aucune application ne se ferme sous Android , SampleActivity.this.finish (); va terminer 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();
Créez une ExitActivity et déclarez-la dans le manifeste. Et appelez ExitActivity.exit(context) pour 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);
}
}
Vous feriez mieux d'utiliser finish() si vous êtes dans Activity ou getActivity().finish() si vous êtes dans Fragment.
Si vous voulez quitter complètement l'application, utilisez:
getActivity().finish();
System.exit(0);
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 peu de temps . Si vous fermez votre application de cette façon et que vous 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 immédiatement votre application . Mais il est possible que vous endommagiez les fichiers ouverts par votre application ou qu'une modification des préférences partagées ne se termine pas. Alors utilisez ceci avec précaution.
Si vous utilisez Watchdog en combinaison avec une tâche longue, 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 au bout de 2 secondes sans afficher de boîte de dialogue ANR ou quelque chose du genre. 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.
Tout d’abord, cette approche nécessite au minimum Api 16.
Je vais diviser cette solution en 3 parties pour résoudre ce problème plus largement.
1. Si vous voulez quitter l'application dans un 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 voulez quitter une application dans une classe non Activity qui a un accès à Activity, utilisez le fragment de code suivant:
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 autre que 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 le récepteur désinscrit à la méthode d'activité onDestroy ()
mLocalBroadcastManager.unregisterReceiver(mBroadcastReceiver);
Pour quitter une 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"));
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 souhaite accéder de manière globale. 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 méthode finish() 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 la valeur 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 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 la relève et de procéder au nettoyage nécessaire.
Encore une fois, je ne sais pas si cela serait mal vu pour une raison quelconque. Si oui, j'aimerais lire des commentaires sur pourquoi et comment il peut être amélioré!
Je pense que ce que tu cherches c'est
activity.moveTaskToBack(Boolean nonRoot);
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);
public void quit() {
int pid = Android.os.Process.myPid();
Android.os.Process.killProcess(pid);
System.exit(0);
}
Est-ce que quitter une application est mal vu? . Passez par ce lien. Cela répond à votre question. Le système tue une application.
Supposons que vous ayez deux activités, A et B. Vous naviguez de A à B. Lorsque vous cliquez sur le bouton Précédent, votre activité B apparaît dans l’arrière-pile et est détruite. L'activité précédente dans l'activité de pile arrière A prend le focus.
Vous devez laisser le système décider quand tuer l'application.
finish() vide public
Appelez-le lorsque votre activité est terminée et devrait être fermée.
Supposons que vous ayez de nombreuses activités. vous pouvez utiliser la barre d'action. En cliquant sur l'icône d'accueil naviagate à MainActivity de votre application. Dans MainActivity, cliquez sur le bouton Précédent 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 tardif et selon les directives, vous n'êtes pas censé gérer vous-même le processus du cycle de vie (comme l'OS le fait pour vous). Une suggestion serait que vous enregistriez un récepteur de radiodiffusion dans toutes vos activités avec "finish()" dans leur onReceive() & chaque fois que vous souhaitiez quitter, vous pouvez simplement transmettre une intention indiquant que toutes les activités doivent être arrêtées ..... Assurez-vous de "désinscrire" le récepteur dans vos méthodes onDestroy().
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 si c'est absolument inévitable. Cela permet aux applications de démarrer plus rapidement, car elles sont toujours conservées en mémoire. Donc, vous avez besoin d'une raison très spéciale pour tuer le processus de votre application.
Similaire à @MobileMateo, mais dans Kotlin
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
this.finishAffinity()
} else{
this.finish()
System.exit(0)
}
La solution correcte et exacte de quit l'application surclic sur le boutonutilise le code ci-dessous:
// événement bouton enfoncé à l'arrière
public void onBackPressed()
{
moveTaskToBack(true);
finish();
}
La réponse de @Sivi ferme l'application. Mais au retour, si vous avez des activités pour enfants, une autre activité inachevée peut être ouverte. J'ai ajouté noHistory:true à mes activités afin que l'application au retour démarre à partir de MainActivity.
<activity
Android:name=".MainActivity"
Android:noHistory="true">
</activity>
Cela tuera n'importe quoi;)
int p = Android.os.Process.myPid();
Android.os.Process.killProcess(p);
Le moyen le plus simple que j'ai trouvé de quitter une application d'une activité sans rompre la logique d'Android ni ajouter de code dans les activités existantes et transmettre des 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 ();
}
la QuitApplicationActivity étant:
public class QuitApplicationActivity extends AppCompatActivity {
@Override
protected void onCreate (Bundle savedInstanceState) {
super.onCreate (savedInstanceState);
finish ();
}
}
Nous voulons un code robuste et simple . Cette solution fonctionne sur les anciens et les nouveaux appareils.
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
getActivity().finishAffinity();
} else{
getActivity().finish();
System.exit( 0 );
}
Si vous utilisez Kotlin, la méthode appropriée pour quitter l'application et l'alternative à System.exit() est une méthode intégrée.
exitProcess(0)
Voir le documentation .
Le nombre 0 en tant que paramètre signifie que l'exit est prévu et qu'aucune erreur ne s'est produite.
Essaye ça
int pid = Android.os.Process.myPid();
Android.os.Process.killProcess(pid);
De votre activité de haut niveau:
super.onBackPressed();