android - samsung - mi celular se reinicia solo y no prende

La aplicación de Android se reinicia al cerrarse la fuerza/fuerza

Question

Mi aplicación de Android se reinicia después del cierre forzado, a través de toda mi aplicación, que consta de 20 actividades, confío en los datos estáticos creados en una actividad principal. Así que una vez que la aplicación se bloquea, todos mis datos estáticos se pierden y cuando la aplicación se reinicia prácticamente, no tiene datos esenciales sobre los que operar.

Mi pregunta es, en caso de choque quiero que esto suceda

1. Si la aplicación falla, no quiero que la aplicación se reinicie, quiero que toda la pila / tarea relacionada con esta aplicación se borre de la memoria. Un usuario puede reiniciarlo de nuevo desde el principio.
2. Si no puedo evitar que la aplicación se reinicie, al menos quiero conservar los datos esenciales para que cuando la aplicación se reinicie pueda volver a asignarlos. También cuando se reinicia quiero que mi aplicación se inicie desde la actividad principal.

Sé cuándo se bloquea la actividad el sistema Android traerá la siguiente actividad en la pila al primer plano, y esta es la razón por la que mi aplicación produce resultados redundantes. También pasé por los desarrolladores de Android, pero lo único que pude saber fue la configuración de un atributo en Manifest android:finishOnTaskLaunch="true" . Pero desafortunadamente esto no me sirve de nada. Apreciaría su ayuda para resolver este problema y también me informaría sobre la causa y el análisis.

Answer 1

1. La mejor solución sería en lugar de usar datos estáticos, usar Shared Preferences o almacenar datos en una Database y, si se produce una uncaught Exception , mostrar un mensaje como Application has crashed and a report is sent to the admin y luego reinicia la Actividad que causó el Bloqueo . De esta manera el usuario puede seguir utilizando la aplicación.

2. Haga lo mismo, pero en lugar de reiniciar la actividad que causó la excepción, reinicie la aplicación.

crear una clase utilizada para manejar 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);
    }
}

y en cada Actividad, crea un Objeto de esta clase y DefaultUncaughtExceptionHandler como DefaultUncaughtExceptionHandler

    Thread.setDefaultUncaughtExceptionHandler(new MyExceptionHandler(this,
            YourCurrentActivity.class));

Answer 2

Bueno, una aplicación no es solo una interfaz (actividades). Imagine que tiene una aplicación empresarial compleja, que utiliza transacciones de SQL, seguridad, autenticación web, etc. Es casi imposible que cada actividad pueda recuperar todo el contexto de la aplicación utilizando solo las Preferencias Compartidas. Entonces en este caso, uso este código:

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

Answer 3

Mi aplicación también se reanudó con la pantalla en blanco, cuando se bloqueó. Para resolver esto, verifiqué el objeto savedInstanceState en el método onCreate de mi actividad principal y, si no es nulo (significa que el sistema Android lo reinició), terminé mi actividad. Algo como eso:

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    if (savedInstanceState != null) {
        finish();
    }
}

También puede ayudar en su caso.

Answer 4

No almacenar datos en campos estáticos. Su proceso podría detenerse en un evento de poca memoria y perderá todo. Sus actividades se restaurarán del estado guardado si el usuario cambia de nuevo a su aplicación, pero sus variables estáticas no se restaurarán.

Answer 5

Si el usuario está forzando la detención de su aplicación (desde Configuración> Aplicaciones> Información de la aplicación, o desde la lista de aplicaciones recientes) o si el sistema operativo está deteniendo su aplicación, puede guardar lo que necesite usando onSaveInstanceState() .

Sin embargo, si su aplicación falla, no hay mucho que pueda hacer al respecto (aparte de guardar periódicamente cosas importantes en preferencias / bases de datos / etc.) Probablemente sea mejor enfocarse en prevenir choques, en lugar de tratar de manejarlos.

Answer 6

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

(Referencia: Archie.bpgc)

Answer 7

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