Android Application Redémarre sur arrêt/de la force de fermeture

Mon application android est l'obtention d'un redémarrage après l'forcer la fermeture, par le biais de l'ensemble de mon application qui se composent de 20 activités, je me fonde sur des données statiques créés sur une activité principale. Donc, une fois que l'application est plantage toutes mes données statiques est de se perdre et lorsque l'application automatique redémarre en pratique, il n'a pas toutes les données essentielles afin d'opérer sur.

Ma question est, sur crash je veux ce que les choses arrivent

Si l'application se bloque, je ne veux pas l'application de redémarrer plutôt je veux que toute la pile de tâches liées à cette application pour être effacé de la mémoire. Un utilisateur peut recommencer depuis le début
Si je ne peux pas empêcher l'application de redémarrer, au moins je veux préserver les données essentielles de sorte que lorsque l'application redémarre je peut les affecter en retour. Aussi, quand il redémarre, je veux que mon application pour démarrer à partir de l'activité principale.

Je sais que lorsque l'activité des plantages du système android va apporter de l'activité suivante dans la pile de premier plan, et c'est la raison pour mon app produire des résultats redondants. aussi je suis passé par les développeurs android mais la seule chose que j'ai appris à connaître, mise en place d'un attribut dans le Manifeste android:finishOnTaskLaunch="true". Mais malheureusement ce n'est d'aucune aide pour moi. Je vous remercie de votre aide sur la résolution de ce problème, et m'a permis de connaître la cause et de l'analyse.

Fil de discussion.setDefaultUncaughtExceptionHandler(nouveau UncaughtExceptionHandler); il suffit de googler!
vérifier cet article pour redémarrer votre application sur un cas d'exception.

InformationsquelleAutor Techfist | 2012-09-24

49
1. Meilleure solution serait plutôt de l'utilisation de données Statiques, utilisez Shared Preferences ou stocker des données dans un Database et si tout uncaught Exception se produit, afficher un message comme Application has crashed and a report is sent to the admin puis redémarrez l'Activité qui a causé le Crash. De cette façon, l'utilisateur peut continuer à utiliser l'application.
2. Faire la même chose mais au lieu de redémarrer l'Activité qui a causé l'Exception de redémarrer l'application.
créer une classe utilisée pour gérer unCaughtException
```
public class MyExceptionHandler implements
        java.lang.Thread.UncaughtExceptionHandler {
    private final Context myContext;
    private final Class<?> myActivityClass;

    public MyExceptionHandler(Context context, Class<?> c) {

        myContext = context;
        myActivityClass = c;
    }

    public void uncaughtException(Thread thread, Throwable exception) {

        StringWriter stackTrace = new StringWriter();
        exception.printStackTrace(new PrintWriter(stackTrace));
        System.err.println(stackTrace);//You can use LogCat too
        Intent intent = new Intent(myContext, myActivityClass);
        String s = stackTrace.toString();
        //you can use this String to know what caused the exception and in which Activity
        intent.putExtra("uncaughtException",
                "Exception is: " + stackTrace.toString());
        intent.putExtra("stacktrace", s);
        myContext.startActivity(intent);
        //for restarting the Activity
        Process.killProcess(Process.myPid());
        System.exit(0);
    }
}
```
et dans chaque Activité, créez un Objet de cette classe et le définir comme le DefaultUncaughtExceptionHandler
```
    Thread.setDefaultUncaughtExceptionHandler(new MyExceptionHandler(this,
            YourCurrentActivity.class));
```
- Je vous remercie beaucoup.vous êtes le seul me sauver. 🙂
- en fait vous n'en avez pas besoin dans chaque activité, comme c'est le Thread UncaughtExceptionHandler, vous avez juste besoin de le faire qu'une fois sur chaque thread. donc, si vos activités sont toujours en cours d'exécution sur le même thread Principal (qui est généralement le cas), il vous suffit d'utiliser Thread.setDefaultUncaughtExceptionHandler sur votre lanceur activité
- Hai comment puis-je obtenir myPid()
- Essayez import android.os.Process; pour éviter les conflits avec la valeur par défaut java.lang.Process.
- Excellente réponse
- Pour obtenir la trace de la pile vous pouvez utiliser: connectez-vous.getStackTraceString(exception);
InformationsquelleAutor Archie.bpgc

public class MyApp extends Application {
    private static final String TAG = "MyApp";
    private static final String KEY_APP_CRASHED = "KEY_APP_CRASHED";

    @Override
    public void onCreate() {
        super.onCreate();

        final UncaughtExceptionHandler defaultHandler = Thread.getDefaultUncaughtExceptionHandler();
        Thread.setDefaultUncaughtExceptionHandler( new UncaughtExceptionHandler() {
            @Override
            public void uncaughtException(Thread thread, Throwable exception) {
                //Save the fact we crashed out.
                getSharedPreferences( TAG , Context.MODE_PRIVATE ).edit()
                    .putBoolean( KEY_APP_CRASHED, true ).apply();
                //Chain default exception handler.
                if ( defaultHandler != null ) {
                    defaultHandler.uncaughtException( thread, exception );
                }
            }
        } );

        boolean bRestartAfterCrash = getSharedPreferences( TAG , Context.MODE_PRIVATE )
                .getBoolean( KEY_APP_CRASHED, false );
        if ( bRestartAfterCrash ) {
            //Clear crash flag.
            getSharedPreferences( TAG , Context.MODE_PRIVATE ).edit()
                .putBoolean( KEY_APP_CRASHED, false ).apply();
            //Re-launch from root activity with cleared stack.
            Intent intent = new Intent( this, MyRootActivity.class );
            intent.addFlags( Intent.FLAG_ACTIVITY_CLEAR_TASK | Intent.FLAG_ACTIVITY_NEW_TASK );
            startActivity( intent );
        }
    }
}

ne devrions-nous pas ajouter de Processus.killProcess(Processus.myPid()); dans cette méthode?

InformationsquelleAutor Paul

  setContentView(R.layout.current);

  Thread.setDefaultUncaughtExceptionHandler(new UncaughtExceptionHandler() {

  @Override
  public void uncaughtException(Thread t, Throwable e) {
        android.os.Process.killProcess(android.os.Process.myPid());
        System.exit(0);
  }

  code....

(référence: Archie.bpgc)

InformationsquelleAutor PhuocLuong

1

Si l'utilisateur est de forcer l'arrêt de votre application (dans Paramètres > Applications > informations sur l'Application, ou de la récente liste des applications) ou le système d'exploitation est l'arrêt de votre application, vous pouvez sauvegarder ce que vous avez besoin de l'aide de onSaveInstanceState().

Toutefois, si votre application est en panne, alors il n'y a pas beaucoup que vous pouvez faire à ce sujet (à part périodiquement sauver des choses importantes à préférences/bases de données/etc.). Il est probablement préférable de se concentrer sur la prévention des accidents, plutôt que d'essayer de gérer les blocages!

InformationsquelleAutor UgglyNoodle
1

Ne pas stocker des données dans des champs statiques.
Votre processus pourrait être arrêté sur le bas de la mémoire de l'événement et vous aurez tout perdu.
Vos activités seront restaurées à partir de l'état enregistré si l'utilisateur commutateur à votre application, mais vos variables statiques ne sera pas restauré.

InformationsquelleAutor konmik

Bien, une application n'est pas seulement de l'interface(les activités). Imaginez que vous avez certains d'applications d'entreprise complexes, à l'aide de SQL transactions, la sécurité, l'Authentification Web, etc..
Il est presque impossible de faire de chaque activité en mesure de récupérer l'ensemble de l'application de contexte à l'aide de seulement Partagé Préférences.
Donc, dans ce cas, j'utilise ce bout de Code:

public class MyApplication extends Application {
  private static final String TAG = "my.app";   
  public static final String MainActivityName = "my.app.top.activity";

  @Override
  public void onCreate() {

    try{
        ActivityManager am = (ActivityManager) this .getSystemService(ACTIVITY_SERVICE);
        List<ActivityManager.RunningTaskInfo> taskInfo = am.getRunningTasks(1);
        ComponentName componentInfo = taskInfo.get(0).topActivity;
        if (MainActivityName.length()>0 && !componentInfo.getClassName().equals(MainActivityName)){
            Log.d(TAG, "Partial Restart Not Supported! : " +componentInfo.getClassName());
            android.os.Process.killProcess(android.os.Process.myPid());
            System.exit(0);
            return;
        }else
            Log.d(TAG, "!!! BCSApplication topActivity=" +componentInfo.getClassName());
    }catch(Exception eee){}

    super.onCreate();
    /*
    ....
    */
 }
/*
    ....
*/
}

InformationsquelleAutor BCS Software

0

Mon application a été également repris avec écran vide, quand il a été s'est écrasé. Pour résoudre ce problème, j'ai vérifié le savedInstanceState objet sur la méthode onCreate de mon activité principale, et si elle n'est pas null (ce qui signifie qu'il est repris par système android) puis j'ai fini mon activité. Quelque chose comme ça:
```
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    if (savedInstanceState != null) {
        finish();
    }
}
```
Il peut être utile dans votre cas aussi.
- C'est une mauvaise chose à faire. Une activité obtient également repris dans les changements de configuration telles que la rotation de l'appareil. Oui, vous pouvez le faire de sorte que vous gérer votre propre modifications de la configuration, mais si l'on y ajoute seulement pour rendre ce code fonctionne correctement, alors vous ne devriez pas faire ça.
InformationsquelleAutor Shivam

Vous devez vous connecter pour publier un commentaire.