Fermer l'application et le lancement écran d'accueil sur Android

Question

J'ai deux activités différentes. Le premier lance le second. Dans la deuxième activité, je l'appelle System.exit(0) afin de forcer l'application à fermer, mais la première activité est automatiquement affichée au lieu de l'application de revenir à l'écran d'accueil. Comment puis-je éviter cela, et obtenir l'application pour revenir à l'écran d'accueil?

Answer 1

Vous devriez vraiment penser à ne pas quitter l'application. Ce n'est pas comment les applications Android fonctionnent habituellement.

Answer 2

Réponse courte: appel moveTaskToBack(true) sur votre Activity au lieu de System.exit(). Cela permet de masquer votre application jusqu'à ce que l'utilisateur veut l'utiliser à nouveau.

La réponse commence plus par une autre question: pourquoi voulez-vous tuer votre application

Le système d'exploitation Android gère la gestion de la mémoire et des processus et ainsi de suite donc mon conseil est simplement laissé Android vous inquiétez pas à ce sujet pour vous. Si l'utilisateur veut quitter votre application, ils peuvent appuyer sur le bouton Home et votre application, disparaîtra. Si le téléphone a besoin de plus de mémoire plus tard, le système d'exploitation mettra fin à votre application, puis.

Tant que vous êtes répondre aux événements du cycle de vie de manière appropriée , ni vous, ni l'utilisateur a besoin de soins si votre demande est toujours en cours ou non.

Donc, si vous voulez masquer votre appel demande moveTaskToBack() et laissez Android décider quand le tuer.

Answer 3

La façon la plus simple pour y parvenir est donnée ci-dessous (sans affecter la gestion de la mémoire native d'Android. Il n'y a pas de processus tuer impliqué).

1. Lancer une activité à l'aide de cette intention:

   Intent intent = new Intent(this, FinActivity.class);
   intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
   startActivity(intent);
   finish();
   

2. Dans l'activité cible FinActivity.class, appeler finish () dans onCreate.

Les étapes Explained:

1. Vous créez une intention qui efface toutes les autres activités (FLAG_ACTIVITY_CLEAR_TOP) et de supprimer l'activité en cours.

2. L'activité elle-même détruit. Une alternative est que vous pouvez faire un écran de démarrage dans finActivity. Cette option est facultative.

Answer 4

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é qui sont entrées lorsque l'application a commencé) il suffit de placer quelques lignes dans la méthode OnDestroy (). L'appel à System.runFinalizersOnExit (true) veille à ce que seront finalisés et les déchets collectés tous les objets lorsque les sorties de l'application. Par exemple:

public void onDestroy() {
    super.onDestroy();

    /*
     * Notify the system to finalize and collect all objects of the
     * application on exit so that the process running the application can
     * be killed by the system without causing issues. NOTE: If this is set
     * to true then the process will not be killed until all of its threads
     * have closed.
     */
    System.runFinalizersOnExit(true);

    /*
     * Force the system to close the application down completely instead of
     * retaining it in the background. The process that runs the application
     * will be killed. The application will be completely created as a new
     * application in a new process if the user starts the application
     * again.
     */
    System.exit(0);
}

Enfin Android ne sera pas notifier une application de la HOME événement clé, de sorte que vous ne pouvez pas fermer l'application lorsque le HOME touche. Android se réserve le HOME événement clé pour lui-même afin qu'un développeur ne peut pas empêcher les utilisateurs de quitter leur application.

Answer 5

Vous pouvez également spécifier Nohistory = « true "dans la balise pour la première activité ou terminer la première activité dès que vous commencez la deuxième (comme David dit).

AFAIK, « la force de fermeture » tue le processus qui héberge la machine virtuelle Java dans lequel fonctionne votre application et System.exit () met fin à la machine virtuelle Java en cours d'exécution de votre instance d'application. Les deux sont sous forme de terminaisons abruptes et non souhaitable pour le débit d'application normale.

De même que la capture d'exceptions pour couvrir les flux logique qu'un programme pourrait entreprendre, n'est pas souhaitable.

Answer 6

J'utilise cette méthode pour fermer les activités!

public static void closeAllBelowActivities(Activity current) {
    boolean flag = true;
    Activity below = current.getParent();
    if (below == null)
        return;
    System.out.println("Below Parent: " + below.getClass());
    while (flag) {
        Activity temp = below;
        try {
            below = temp.getParent();
            temp.finish();
        } catch (Exception e) {
            flag = false;
        }
    }
}

Answer 7

Lorsque vous lancez la deuxième activité, finish() le premier immédiatement:

startActivity(new Intent(...));
finish();

Answer 8

android.os.Process.killProcess(android.os.Process.myPid()); fonctionne très bien, mais il est recommandé de laisser le souci de la plate-forme Android sur la gestion de la mémoire: -)

Answer 9

Vous ne pouvez pas faire System.exit (), ce n'est pas sûr.

Vous pouvez faire celui-ci: Process.killProcess (Process.myPid ());

Answer 10

J'utilise ceci:

1) L'activité de parent appelle l'activité secondaire avec la méthode "startActivityForResult"

2) Dans l'activité secondaire lorsque la fermeture est:

int exitCode = 1; // Select the number you want
setResult(exitCode);
finish();

3) et dans l'activité de parent remplacer la méthode "onActivityResult":

public void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    int exitCode = 1;
    if(resultCode == exitCode) {
        super.setResult(exitCode); // use this if you have more than 2 activities
        finish();
    }
}

Cela fonctionne bien pour moi.

Answer 11

Utilisez la méthode finish. Il est la méthode plus simple et plus facile.

this.finish();

Answer 12

Gardez à l'esprit que lorsque vous travaillez avec des applications qui utilisent des connexions socket persistantes, la méthode finish() ne libère pas la connexion. Dans des circonstances normales, finish() est la meilleure option, mais si vous devez absolument sortir une application et libérer toutes les ressources qu'il utilise ensuite utiliser killProcess. J'ai eu aucun problème à l'utiliser.

Answer 13

Démarrer la deuxième activité avec startActivityForResult et dans la deuxième activité renvoyer une valeur, une fois que dans le procédé de onActivityResult de la première action ferme l'application principale. Je pense que cela est la manière correcte Android le fait.

Answer 14

Essayez ce qui suit. Il fonctionne pour moi.

ActivityManager am = (ActivityManager) this.getSystemService(ACTIVITY_SERVICE);
List<ActivityManager.RunningTaskInfo> taskInfo = am.getRunningTasks(1); 
ComponentName componentInfo = taskInfo.get(0).topActivity;
am.restartPackage(componentInfo.getPackageName());

Answer 15

Disons que vous avez pile d'activité comme A> B> C> D> E. Vous êtes à l'activité D, et que vous voulez fermer votre application. Voici ce que vous faites wil -

Dans l'activité de l'endroit où vous souhaitez fermer (Activité D) -

Intent intent = new Intent(D.this,A.class);
intent.putExtra("exit", "exit");
intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP| Intent.FLAG_ACTIVITY_SINGLE_TOP);
startActivity(intent);

Dans votre RootActivity (votre activité de base, ici Activité A) -

@Override
    protected void onNewIntent(Intent intent) {
        super.onNewIntent(intent);
        if (intent.hasExtra("exit")) {
            setIntent(intent);
        }
    }

    @Override
    protected void onResume() {
        super.onResume();
        if (getIntent() != null) {
            if (("exit").equalsIgnoreCase(getIntent().getStringExtra(("exit")))) {
                onBackPressed();
            }
        }
    }

onNewIntent est utilisé parce que si l'activité est en vie, il obtiendra la première intention qui a commencé. Pas le nouveau. Pour plus de détails - Documentation

Answer 16

Il est en fait calme facile.

La façon dont je le fais est en sauvant un drapeau dans une variable statique disponible à tous. Puis, quand je sors, je mets ce drapeau et toutes mes activités vérifier ce drapeau onResume. Si le drapeau est réglé alors je lance la System.exit sur cette activité.

De cette façon, toutes les activités vérifieront pour le drapeau et fermeront gracieusement si le drapeau est réglé.

Answer 17

Vous avez tort. Il y a une façon de tuer une application. Dans une classe avec application super classe, nous utilisons un champ, par exemple, killApp. Quand on commence à l'écran de démarrage (première activité) en onResume(), nous avons établi un paramètre pour faux pour killApp sur le terrain. Dans toutes les activités que nous avons quand onResume() est appelé à la fin, nous appelons quelque chose comme ça:

if(AppClass.killApp())
    finish();

Toute activité qui devient à l'écran doivent appeler onResume(). Quand on l'appelle, nous devons vérifier si notre killApp sur le terrain est vrai. S'il est vrai, les activités actuelles appellent finish(). Pour invoquer l'action complète, nous utilisons la prochaine construction. Par exemple, dans l'action d'un bouton:

AppClass.setkillApplication(true);
   finish();
   return;

Answer 18

est ce que je l'ai fait pour fermer l'application: Dans ma demande, j'ai une classe d'activité de base, j'ai ajouté un drapeau statique appelé « applicationShutDown ». Quand je dois fermer l'application je l'ai mis à true.

Dans l'activité de base onCreate et onResume après avoir appelé les super appels que j'ai testé ce drapeau. Si le « applicationShutDown » est vrai que j'appelle la finition sur l'activité en cours.

Cela a fonctionné pour moi:

protected void onResume() {
    super.onResume();
    if(BaseActivity.shutDownApp)
    {
        finish();
        return;

    }}

Answer 19

Exécuter la deuxième activité en utilisant l'activité de démarrage pour résultat:

Intent intent = new Intent(FirstActivity.this, SecondActivity.class);

//This line is important
intent.addFlags(Intent.FLAG_ACTIVITY_REORDER_TO_FRONT);

startActivityForResult(intent, REQUEST_CODE);

Ajoutez cette fonction à la première activité:

@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    if(rquestCode == REQUEST_CODE)
        if(resultCode == RESULT_CANCELED)
            finish();
}

Et ajouter à la deuxième activité:

@Override
public boolean onKeyDown(int keyCode, KeyEvent event)  {
    if (keyCode == KeyEvent.KEYCODE_BACK && event.getRepeatCount() == 0) {

        Log.i(TAG, "Back key pressed");
        setResult(RESULT_CANCELED);
        finish();
        return true;
    }
    return super.onKeyDown(keyCode, event);
}

Answer 20

Il est pas recommandé, mais vous pouvez toujours utiliser cela. Mieux vaut aller avec cette solution dans le cas où vous avez besoin de quitter l'application.

Selon moi, la meilleure solution est de terminer toutes les activités dans votre application comme ci-dessous.

Étape 1. Maintenir une variable statique dans MainActivity. Dites,

public static boolean isQuit = false;

Étape 2. Lors de l'événement de clic d'un bouton, réglez cette variable sur true.

mainactivity.isQuit = true;
finish();

Étape 3. Et dans toutes les activités de votre application, ont la méthode onrestart comme ci-dessous.

@Override
protected void onRestart() {
    // TODO Auto-generated method stub
    super.onRestart();
    if(mainactivity.isQuit)
        finish();
}

Answer 21

Je résolu un problème similaire: MainActivity commence BrowserActivity, et je dois fermer l'application, lorsque l'utilisateur presse Retour à BrowserActivity - ne pas retourner dans MainActivity. Ainsi, dans MainActivity:

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "sm500_Rmt.MainActivity";
    private boolean m_IsBrowserStarted = false;

et puis, dans onResume:

    @Override
protected void onResume() {
    super.onResume();
    if(m_IsBrowserStarted) {
        Log.w(TAG, "onResume, but it's return from browser, just exit!");
        finish();
        return;
    }
    Log.w(TAG, "onResume");

... puis continuer onResume. Et, lorsque le démarrage BrowserActivity:

    Intent intent = new Intent(this, BrowserActivity.class);
    intent.putExtra(getString(R.string.IPAddr), ip);
    startActivity(intent);
    m_IsBrowserStarted = true;

Et il semble que cela fonctionne bien! : -)