Cómo volver a lanzar una excepción

Question

En mi onCreate() configurar un controlador uncaughtException de la siguiente manera:

Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() { 
    @Override 
    public void uncaughtException(Thread thread, Throwable throwable) { 
     Log.e(getMethodName(2), "uncaughtException", throwable); 
     android.os.Process.killProcess(android.os.Process.myPid()); 
    } 
}); 

Funciona bien, pero me gustaría volver el comportamiento predeterminado del sistema de visualización de la fuerza- cerrar el diálogo al usuario.

Si trato de reemplazar la llamada KillProcess() con un throw throwable, el compilador se queja de que necesito rodearlo con un try/catch.

Si me rodeo con un try/catch:

Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() { 
    @Override 
    public void uncaughtException(Thread thread, Throwable throwable) { 
     try { 
      Log.e(getMethodName(2), "uncaughtException", throwable); 
      throw throwable; 
     } 
     catch (Exception e) {   
     } 
     finally {    
     } 
    } 
}); 

El compilador se queja de que todavía queda mucho por throw throwable rodeados con un try/catch.

¿Cómo vuelvo a tirar ese arrojar? Tal que a excepción de ese informativo Log.e() el sistema se comporta exactamente como antes: Como nunca he configurado un controlador predeterminado UncaughtException.

Answer 1

Probar:

public class CustomExceptionHandler implements UncaughtExceptionHandler { 

    private UncaughtExceptionHandler defaultUEH; 

    public CustomExceptionHandler() { 
     this.defaultUEH = Thread.getDefaultUncaughtExceptionHandler(); 
    } 

    public void uncaughtException(Thread t, Throwable e) { 
     Log.e("Tag", "uncaughtException", throwable); 
     defaultUEH.uncaughtException(t, e); 
    } 
} 

y luego Thread.setDefaultUncaughtExceptionHandler(new CustomExceptionHandler());

Adaptado de this respuesta.

Answer 2

Si configura el manejador de excepciones no detectadas predeterminado, se espera que consuma la excepción en él. Esto se refleja en el hecho de que uncaughtException no declara ninguna excepción.

No debería haber ninguna razón obvia para volver a lanzarlo. Simplemente se imprimirá en el registro por segunda vez y el hilo morirá de todos modos. Si realmente quieres eso, simplemente envuelve throwable en RuntimeException y vuelve a lanzar.

Answer 3

No hay razón para volver a lanzar el Throwable, según el javadoc, it is simply ignored. El hilo termina en este punto, solo está configurando las últimas acciones que debe intentar antes de salir.

Por el bien del argumento, si se quería volver a lanzar un throwable, usted haría algo como esto:

public void reThrow(Throwable t) { 
    if (RuntimeException.class.isAssignableFrom(t.getClass())) { 
     throw (RuntimeException)t; 
    } else if (Error.class.isAssignableFrom(t.getClass())) { 
     throw (Error) t; 
    } else { 
     throw new UndeclaredThrowableException(t); 
    } 
} 

Answer 4

en primer lugar, no es necesario volver a generar la excepción. uncaughtException() no consume la excepción. sin embargo, debe llamar al método predeterminado del manejador de excepciones no detectadas. algo así como,

class MyUEH implements UncaughtExceptionHandler { 
    private static final UncaughtExceptionHandler default = Thread.getDefaultUncaughtExceptionHandler(); 

    public void uncaughtException(Thread t, Throwable e) { 
     Log.e("Tag", "uncaughtException", throwable); 
     default.uncaughtException(t, e); 
    } 
} 

segundo, no necesita matar el proceso usted mismo. el UEH predeterminado manejará eso cuando llame a través de él.

En tercer lugar, el UEH predeterminado mostrará (o hará que se muestre) el cuadro de diálogo estándar de bloqueo (cierre forzado) para el usuario. tenga en cuenta que si su método se bloquea (porque está haciendo IO, por ejemplo), entonces el usuario no verá el diálogo de bloqueo hasta que su método finalice.