¿En qué se diferencia Log.wtf() de Log.e()?

he mirado la documentación para android.util.Log y no estoy seguro exactamente cuál es la diferencia entre Log.e() y Log.wtf() es. ¿Se prefiere uno sobre el otro? ¿Hay alguna diferencia de funcionalidad? Seguramente no son redundantes.

Nota para futuros lectores: En el momento en que se hizo esta pregunta, la documentación para esto era mucho menos clara. Si sigues el enlace de arriba, han solucionado el problema.

Hay una diferencia en la severidad;

Log.e() simplemente registrará un error en el registro con prioridad ERROR.

Log.wtf() registrará un error con el nivel de prioridad ASSERT y puede (dependiendo de la configuración del sistema) enviar un informe de error y terminar el programa inmediatamente.

ERROR COMÚN

documentos oficiales decir:

Log.e() registros con prioridad ERROR. Sin embargo, Log.wtf() registros con prioridad ASSERT.

ASSERT tiene prioridad constante = 7
ERROR tiene prioridad constante = 6

Asi que Log.wtf() tiene mayor prioridad con respecto a Log.e()

Sin embargo código fuente conflictos con la información anterior.

static int wtf(int logId, String tag, String msg, Throwable tr,boolean localStack, boolean system) {
        
    TerribleFailure what = new TerribleFailure(msg, tr);
    // Only mark this as ERROR, do not use ASSERT since that should be
    // reserved for cases where the system is guaranteed to abort.
    // The onTerribleFailure call does not always cause a crash.
    int bytes = printlns(logId, ERROR, tag, msg, localStack ? what : tr);
    ...
}

Parece que hay un error en Documentos oficiales. porque ambos Log.wtf() y Log.e() registros con prioridad ERROR.

DIFERENCIA REAL

Código fuente para Log.e():

public static int e(@Nullable String tag, @Nullable String msg,@Nullable Throwable tr) {
    return printlns(LOG_ID_MAIN, ERROR, tag, msg, tr);
}

La diferencia es que Log.wtf() podría devolver la llamada a onTerribleFailure().

onTerribleFailure() puede o no causar que el proceso finalice (depende de la configuración del sistema).

TL;DR

Log.wtf() puede llamar a TerribleFailure() y puede causar la terminación de su aplicación.

Log.e() es simplemente registrar un error en el registro con prioridad como ERROR.

Log.wtf() (Qué terrible falla) es más grave que el registro de errores. El error que nunca jamás, jamás sucedió. Puede obligar al dispositivo a esperar para escribir los registros antes de finalizar el programa.

En realidad, esto podría ser un error de documentación en Android SDK, qué sorpresa… Doc dice:

El error siempre se registrará en el nivel ASSERT con la pila de llamadas.

Pero el código fuente dice esto:

static int wtf(int logId, String tag, String msg, Throwable tr, boolean localStack, boolean system) {

    ...

    int bytes = printlns(logId, ERROR, tag, msg, localStack ? what : tr);

    ...
}

Entonces, Log.wtf() y Log.e() tienen la misma prioridad, ERROR.

La diferencia es que Log.wtf() solicita la devolución de llamada de onTerribleFailure(), que “Informa de un error grave en el proceso actual. Puede o no hacer que el proceso finalice (depende de la configuración del sistema)”.

Entonces, en otras palabras, Log.wtf() podría bloquear su aplicación.

A continuación se muestra un fragmento de código:

if (ActivityManager.getService().handleApplicationWtf(
        mApplicationObject, tag, system,
        new ApplicationErrorReport.ParcelableCrashInfo
  // The Activity Manager has already written us off -- now exit.
  Process.killProcess(Process.myPid());
  System.exit(10);
}

Al igual que con los otros tipos de registro, entiendo que es solo otro tipo de etiqueta para los mensajes de registro. log.i es para obtener información sobre dónde está ocurriendo algo. log.e es para errores que podrían ocurrir. log.wtf es para errores que nunca ocurren. Creo que es solo una conveniencia para que no tenga algo como Log(“ERROR:”, “un error”) y Log(“INFO: “, “information”)

Creo que wtf (qué falla tan terrible) se usa para reportar excepciones/problemas serios de sus aplicaciones (por ejemplo, reportarlos en su consola de depuración).

log.e se utiliza para informar errores, pero no tan graves.

No sabía esto hasta que trabajé en la capa ROM.

Log.wtf() terminará su proceso si se establecen ciertas condiciones. Estaba bastante confundido sobre por qué el servicio del sistema fallaba todo el tiempo. Fue que usé Log.wtf() y fue despedido por algo “que nunca debería estar sucediendo”