Devo rimuovere e.printStackTrace() dal mio codice prima di pubblicare

Question

Stavo leggendo i documenti di Android Publishing e mi hanno detto di rimuovere tutte le chiamate di registro dal mio codice. Ho alcune chiamate a e.printStackTrace() nel mio codice che può essere stampato come parte del normale funzionamento del mio programma (ad esempio se un file non esiste ancora).

Devo rimuovere anche queste chiamate?

Answer 1

Non dovrebbe usare e.printStackTrace() direttamente comunque — così facendo inviare le informazioni al registro di Android senza visualizzare quale applicazione (tag log) è venuto.

Come altri hanno già detto, continuare a catturare lo Exception in questione, ma utilizzare uno dei metodi android.util.Log per eseguire la registrazione. Si poteva accedere solo il messaggio, ma non l'analisi dello stack, o utilizzare la registrazione dettagliata per l'analisi dello stack:

try { 
    Object foo = null; 
    foo.toString(); 
} catch (NullPointerException ex) { 
    Log.w(LOG_TAG, "Foo didn't work: "+ ex.getMessage()); 
    Log.d(LOG_TAG, Util.stackTraceWriter(ex)); 
} 

Si dovrebbe spogliare DEBUG o VERBOSE messaggi di log dalla vostra produzione costruisce. Il modo più semplice è quello di use ProGuard to remove Log.[dv] calls dal tuo codice.

Answer 2

a mio modesto parere (io non sono uno sviluppatore Android)

Dovrebbe essere bello. Non conosco le opzioni di registrazione per Android ma sono sicuro che hai qualche cosa configurabile per produrre (o meno) le tue tracce.

E se non si esegue printStackTrace() Android non farà il lavoro sporco di ignorarlo.

:)

è solo un (stile) cosa buona-sentimento.

Answer 3

Se si consente a un'eccezione di propagarsi al sistema operativo, il sistema operativo lo registrerà e aprirà una finestra di chiusura forzata, eliminando l'applicazione. Se la prendi, puoi impedire che l'applicazione venga forzata.

Se si desidera che gli utenti abbiano la possibilità di inviare errori che stanno ottenendo, quindi registrerei la traccia dello stack. Possono quindi inviarti il ​​registro tramite un'app come Log Collector.

Se si desidera evitare la possibilità di esporre le informazioni di traccia dello stack ai propri utenti, quindi rilevare l'eccezione e non registrarla.

Answer 4

Vorrei utilizzare la classe Log per il messaggio out put. Per i log che ritieni importanti per rimanere nell'app, utilizza Log.i per gli avvisi di errore - Log.e Log.w Per eseguire il debug di Log.d - e che puoi disattivare su base se l'applicazione è in debug modalità.

http://developer.android.com/reference/android/util/DebugUtils.html

Answer 5

Bene printStackTrace() registrerà esso nel sistema operativo, causando l'Andorid (o il computer) app per terminare (forza vicino), invece, fare qualcosa di simile:

public void nullPointerExceptionCauser() 
{ 
     try 
     { 
      Object example = null; 
      example.toString(); 
     } 
     catch (Exception e) 
     { 
      Logger.log(Level.SEVERE, "Caught Exception: {0}", e.getStackTrace()); 
     } 
} 

Answer 6

Utilizzare questo per eliminare i registri dal rilascio apk

if (BuildConfig.DEBUG) Log.d(TAG, "your meseage"); 

Answer 7

Se si desidera essere sicuri cioèNon permettere a nessuno snooping di leggere i log di eccezione si può fare qualcosa di simile

private void hideExceptionsInReleaseMode() 
{ 
    final Thread.UncaughtExceptionHandler defaultHandler = Thread.getDefaultUncaughtExceptionHandler(); 

    if(!BuildConfig.DEBUG) 
    { 
     Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() 
      { 
       @Override 
       public void uncaughtException(Thread thread, Throwable ex) 
       { 
        defaultHandler.uncaughtException(thread, new RuntimeException("Something went wrong :p")); 
       } 
      }); 
    } 
} 

Answer 8

Per poter utilizzare printStackTrace in un modo più sicuro userei StringWrite e PrintWriter:

... 
catch (final Exception e) 
{ 
    final StringWriter sw = new StringWriter(); 
    final PrintWriter pw = new PrintWriter(sw); 
    e.printStackTrace(pw); 
    Log.e("TAG", sw.toString()); 
} 

O in alternativa:

catch (final Exception e) 
{ 
    Log.e(TAG, Log.getStackTraceString(e)); 
}