Come rimuovere tutte le chiamate di registrazione di debug prima di creare la versione di rilascio di un'app Android?

Secondo Google, devo " disattivare tutte le chiamate ai metodi Log nel codice sorgente " prima di pubblicare la mia app Android su Google Play. Estratto dalla sezione 3 dell'elenco di controllo della pubblicazione :

Assicurarsi di disattivare la registrazione e disabilitare l'opzione di debug prima di compilare l'applicazione per il rilascio. È possibile disattivare la registrazione rimuovendo le chiamate ai metodi Log nei file di origine.

Il mio progetto open source è ampio ed è una seccatura farlo manualmente ogni volta che lancio. Inoltre, rimuovere una linea di registro è potenzialmente complicato, ad esempio:

if(condition)
  Log.d(LOG_TAG, "Something");
data.load();
data.show();

Se commento la riga Log, la condizione si applica alla riga successiva e le probabilità che load () non venga chiamata. Tali situazioni sono abbastanza rare da poter decidere che non dovrebbe esistere?

Quindi, esiste un modo migliore a livello di codice sorgente per farlo? O forse una sintassi intelligente di ProGuard per rimuovere in modo efficiente ma sicuro tutte le linee di registro?

Trovo che una soluzione molto più semplice sia dimenticare tutti i ifcontrolli dappertutto e usare ProGuard per eliminare qualsiasi chiamata Log.d()o Log.v()metodo quando chiamiamo il nostro releasetarget Ant .

In questo modo, abbiamo sempre l'output delle informazioni di debug per build regolari e non è necessario apportare modifiche al codice per le build di rilascio. ProGuard può anche eseguire più passaggi sul bytecode per rimuovere altre istruzioni indesiderate, blocchi vuoti e può incorporare automaticamente metodi brevi ove appropriato.

Ad esempio, ecco una configurazione ProGuard molto semplice per Android:

-dontskipnonpubliclibraryclasses
-dontobfuscate
-forceprocessing
-optimizationpasses 5

-keep class * extends android.app.Activity
-assumenosideeffects class android.util.Log {
    public static *** d(...);
    public static *** v(...);
}

Quindi lo salveresti su un file, quindi chiamerai ProGuard da Ant, passando il tuo JAR appena compilato e il JAR della piattaforma Android che stai utilizzando.

Vedi anche gli esempi nel manuale ProGuard.

Aggiornamento (4,5 anni dopo): oggi ho usato Timber per la registrazione Android.

Non solo è un po 'più bello dell'implementazione predefinita Log- il tag di registro viene impostato automaticamente ed è facile registrare stringhe ed eccezioni formattate - ma è anche possibile specificare comportamenti di registrazione diversi in fase di esecuzione.

In questo esempio, le istruzioni di registrazione verranno scritte su logcat solo nelle build di debug della mia app:

Il legname è impostato nel mio Application onCreate()metodo:

if (BuildConfig.DEBUG) {
  Timber.plant(new Timber.DebugTree());
}

Quindi in qualsiasi altra parte del mio codice posso accedere facilmente:

Timber.d("Downloading URL: %s", url);
try {
  // ...
} catch (IOException ioe) {
  Timber.e(ioe, "Bad things happened!");
}

Vedi l' app di esempio Timber per un esempio più avanzato, in cui tutte le istruzioni di registro vengono inviate a logcat durante lo sviluppo e, in produzione, non vengono registrate istruzioni di debug, ma gli errori vengono silenziosamente segnalati a Crashlytics.

Tutte buone risposte, ma quando ho terminato il mio sviluppo non volevo usare le istruzioni if ​​intorno a tutte le chiamate di Log, né volevo usare strumenti esterni.

Quindi la soluzione che sto usando è quella di sostituire la classe android.util.Log con la mia classe Log:

public class Log {
    static final boolean LOG = BuildConfig.DEBUG;

    public static void i(String tag, String string) {
        if (LOG) android.util.Log.i(tag, string);
    }
    public static void e(String tag, String string) {
        if (LOG) android.util.Log.e(tag, string);
    }
    public static void d(String tag, String string) {
        if (LOG) android.util.Log.d(tag, string);
    }
    public static void v(String tag, String string) {
        if (LOG) android.util.Log.v(tag, string);
    }
    public static void w(String tag, String string) {
        if (LOG) android.util.Log.w(tag, string);
    }
}

L'unica cosa che dovevo fare in tutti i file sorgente era sostituire l'importazione di android.util.Log con la mia classe.

Suggerisco di avere un booleano statico da qualche parte che indica se accedere o meno:

class MyDebug {
  LOG booleano finale statico = true;
}

Quindi, ovunque tu voglia accedere al tuo codice, basta fare questo:

if (MyDebug.LOG) {
  if (condition) Log.i (...);
}

Ora, quando imposti MyDebug.LOG su false, il compilatore eliminerà tutto il codice all'interno di tali controlli (dato che si tratta di un finale statico, sa al momento della compilazione che il codice non viene utilizzato).

Per progetti più grandi, potresti voler iniziare con booleani nei singoli file per poter abilitare o disabilitare facilmente la registrazione lì, se necessario. Ad esempio, queste sono le varie costanti di registrazione che abbiamo nel gestore delle finestre:

static final String TAG = "WindowManager";
static final boolean DEBUG = false;
static final boolean DEBUG_FOCUS = false;
static final boolean DEBUG_ANIM = false;
static final boolean DEBUG_LAYOUT = false;
static final boolean DEBUG_RESIZE = false;
static final boolean DEBUG_LAYERS = false;
static final boolean DEBUG_INPUT = false;
static final boolean DEBUG_INPUT_METHOD = false;
static final boolean DEBUG_VISIBILITY = false;
static final boolean DEBUG_WINDOW_MOVEMENT = false;
static final boolean DEBUG_ORIENTATION = false;
static final boolean DEBUG_APP_TRANSITIONS = false;
static final boolean DEBUG_STARTING_WINDOW = false;
static final boolean DEBUG_REORDER = false;
static final boolean DEBUG_WALLPAPER = false;
static final boolean SHOW_TRANSACTIONS = false;
static final boolean HIDE_STACK_CRAWLS = true;
static final boolean MEASURE_LATENCY = false;

Con il codice corrispondente come:

    if (DEBUG_FOCUS || DEBUG_WINDOW_MOVEMENT) Log.v(
        TAG, "Adding window " + window + " at "
        + (i+1) + " of " + mWindows.size() + " (after " + pos + ")");

La soluzione Proguard di Christopher è la migliore, ma se per qualsiasi motivo non ti piace Proguard, ecco una soluzione molto low-tech:

Log dei commenti:

find . -name "*\.java" | xargs grep -l 'Log\.' | xargs sed -i 's/Log\./;\/\/ Log\./g'

Registri di non commento:

find . -name "*\.java" | xargs grep -l 'Log\.' | xargs sed -i 's/;\/\/ Log\./Log\./g'

Un vincolo è che le istruzioni di registrazione non devono estendersi su più righe.

(Eseguire queste righe in una shell UNIX alla radice del progetto. Se si utilizza Windows, ottenere un livello UNIX o utilizzare comandi Windows equivalenti)

Vorrei aggiungere alcune precisazioni sull'uso di Proguard con Android Studio e Gradle, poiché ho avuto molti problemi a rimuovere le linee di registro dal file binario finale.

Per far assumenosideeffectsfunzionare Proguard, c'è un prerequisito.

Nel tuo file gradle, devi specificare l'uso del proguard-android-optimize.txtfile predefinito.

buildTypes {
    release {
        minifyEnabled true
        proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'

        // With the file below, it does not work!
        //proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
    }
}

In realtà, nel proguard-android.txtfile predefinito , l'ottimizzazione è disabilitata con i due flag:

-dontoptimize
-dontpreverify

Il proguard-android-optimize.txtfile non aggiunge quelle righe, quindi ora assumenosideeffectspuò funzionare.

Quindi, personalmente, uso SLF4J , tanto più quando sviluppo alcune librerie che sono distribuite ad altri. Il vantaggio è che per impostazione predefinita non c'è output. E se l'integratore desidera alcuni output di log, può utilizzare Logback per Android e attivare i log, in modo che i log possano essere reindirizzati a un file o a LogCat.

Se ho davvero bisogno di eliminare i log dalla libreria finale, aggiungo quindi al mio file Proguard (dopo aver abilitato il proguard-android-optimize.txtfile ovviamente):

-assumenosideeffects class * implements org.slf4j.Logger {
    public *** trace(...);
    public *** debug(...);
    public *** info(...);
    public *** warn(...);
    public *** error(...);
}

Consiglio vivamente di usare Timber di Jake Wharton

https://github.com/JakeWharton/timber

risolve il problema con l'attivazione / disattivazione e aggiunge automaticamente la classe di tag

appena

public class MyApp extends Application {

  public void onCreate() {
    super.onCreate();
    //Timber
    if (BuildConfig.DEBUG) {
      Timber.plant(new DebugTree());
    }
    ...

i log verranno utilizzati solo nella tua versione di debug, quindi verranno utilizzati

Timber.d("lol");

o

Timber.i("lol says %s","lol");

per stampare

"La tua classe / msg" senza specificare il tag

Ho usato una classe LogUtils come nell'applicazione esempio di Google IO. Ho modificato questo per utilizzare una costante DEBUG specifica dell'applicazione anziché BuildConfig.DEBUG perché BuildConfig.DEBUG non è affidabile . Quindi nelle mie lezioni ho quanto segue.

import static my.app.util.LogUtils.makeLogTag;
import static my.app.util.LogUtils.LOGV;

public class MyActivity extends FragmentActivity {
  private static final String TAG = makeLogTag(MyActivity.class);

  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    LOGV(TAG, "my message");
  }
}

Vorrei prendere in considerazione l'utilizzo della funzione di registrazione di roboguice invece di android.util.Log integrato

La loro funzione disabilita automaticamente i log di debug e dettagliati per le build di rilascio. Inoltre, ottieni alcune eleganti funzionalità gratuitamente (ad es. Comportamento di registrazione personalizzabile, dati aggiuntivi per ogni registro e altro)

L'utilizzo di proguard potrebbe essere una seccatura e non avrei problemi a configurarlo e farlo funzionare con la tua applicazione a meno che tu non abbia una buona ragione per farlo (disabilitare i log non è buono)

Sto pubblicando questa soluzione che si applica specificamente agli utenti di Android Studio. Recentemente ho anche scoperto Timber e l'ho importato correttamente nella mia app procedendo come segue:

Inserisci l'ultima versione della libreria nel tuo build.gradle:

compile 'com.jakewharton.timber:timber:4.1.1'

Quindi in Android Studios, vai su Modifica -> Trova -> Sostituisci nel percorso ...

Digita Log.e(TAG,o comunque hai definito i tuoi messaggi di Log nella "Text to find"casella di testo. Quindi lo sostituisci conTimber.e(

Fai clic su Trova, quindi sostituisci tutto.

Android Studios ora esaminerà tutti i tuoi file nel tuo progetto e sostituirà tutti i registri con i legni.

L'unico problema che ho avuto con questo metodo è che Gradle si presenta con milioni di messaggi di errore in seguito perché non riesce a trovare "Timber" nelle importazioni per ciascuno dei tuoi file java. Basta fare clic sugli errori e Android Studios importerà automaticamente "Timber" nel tuo java. Una volta che lo hai fatto per tutti i tuoi file di errori, Gradle verrà nuovamente compilato.

Devi anche inserire questo pezzo di codice nel tuo onCreatemetodo della tua Applicationclasse:

    if (BuildConfig.DEBUG) {
        Timber.plant(new Timber.DebugTree());
    }

Ciò comporterà la registrazione dell'app solo quando ci si trova in modalità di sviluppo e non in produzione. Puoi anche avere BuildConfig.RELEASEper la registrazione in modalità di rilascio.

Per android.util.Log fornisce un modo per abilitare / disabilitare il registro:

public static native boolean isLoggable(String tag, int level);

Per impostazione predefinita, il metodo isLoggable (...) restituisce false, solo dopo che setprop nel dispositivo piace questo:

adb shell setprop log.tag.MyAppTag DEBUG

Significa che qualsiasi registro al di sopra del livello DEBUG può essere stampato. Documento Android di riferimento:

Verifica se un registro per il tag specificato è registrabile al livello specificato. Il livello predefinito di qualsiasi tag è impostato su INFO. Ciò significa che verrà registrato qualsiasi livello superiore e incluso INFO. Prima di effettuare qualsiasi chiamata a un metodo di registrazione, è necessario verificare se il tag deve essere registrato. È possibile modificare il livello predefinito impostando una proprietà di sistema: 'setprop log.tag. 'Dove livello è VERBOSE, DEBUG, INFO, WARN, ERROR, ASSERT o SUPPRESS. SUPPRESS disattiverà tutte le registrazioni per il tuo tag. Puoi anche creare un file local.prop che includa quanto segue: 'log.tag. =' E posizionarlo in /data/local.prop.

Quindi potremmo usare log util personalizzato:

public final class Dlog 
{
    public static void v(String tag, String msg)
    {
        if (Log.isLoggable(tag, Log.VERBOSE))
            Log.v(tag, msg);
    }

    public static void d(String tag, String msg)
    {
        if (Log.isLoggable(tag, Log.DEBUG))
            Log.d(tag, msg);
    }

    public static void i(String tag, String msg)
    {
        if (Log.isLoggable(tag, Log.INFO))
            Log.i(tag, msg);
    }

    public static void w(String tag, String msg)
    {
        if (Log.isLoggable(tag, Log.WARN))
            Log.w(tag, msg);
    }

    public static void e(String tag, String msg)
    {
        if (Log.isLoggable(tag, Log.ERROR))
            Log.e(tag, msg);
    }
}

Se è possibile eseguire una sostituzione globale (una volta) e successivamente conservare alcune convenzioni di codifica, è possibile seguire il modello spesso utilizzato nel framework Android .

Invece di scrivere

Log.d(TAG, string1 + string2 + arg3.toString());

fallo come

if (BuildConfig.DEBUG) Log.d(TAG, string1 + String.format("%.2f", arg2) + arg3.toString());

Ora proguard può rimuovere StringBuilder e tutte le stringhe e i metodi che utilizza lungo la strada, dalla versione ottimizzata DEX. Usa proguard-android-optimize.txte non devi preoccuparti di android.util.Log nel tuo proguard-rules.pro:

android {
  …
  buildTypes {
    release {
      minifyEnabled true
      proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
    }
  }
}

Con il plug-in Android Studio Gradle, è abbastanza affidabile, quindi non hai bisogno di costanti extra per controllare lo stripping.BuildConfig.DEBUG

Aggiungi seguito al tuo file proguard-rules.txt

-assumenosideeffects class android.util.Log {
  public static *** d(...);
  public static *** w(...);
  public static *** v(...);
  public static *** i(...);
}

Questo è quello che facevo nei miei progetti Android ..

In Android Studio possiamo eseguire operazioni simili tramite, Ctrl + Maiusc + F per trovare da tutto il progetto (Comando + Maiusc + F in MacO) e Ctrl + Maiusc + R per Sostituire ((Comando + Maiusc + R in MacO))

Ho una soluzione molto semplice. Uso IntelliJ per lo sviluppo, quindi i dettagli variano ma l'idea dovrebbe applicarsi a tutti gli IDE.

Scelgo la radice del mio albero dei sorgenti, faccio clic con il tasto destro e seleziono per fare "sostituisci". Ho quindi scelto di sostituire tutto "Registro". con "// Log.". Ciò rimuove tutte le istruzioni del registro. Per rimetterli più tardi, ripeto la stessa sostituzione, ma questa volta sostituisco tutto "// Registro". con "Log".

Funziona alla grande per me. Ricorda solo di impostare la sostituzione come maiuscole / minuscole per evitare incidenti come "Finestra di dialogo". Per maggiore sicurezza, puoi anche fare il primo passo con "Log". come stringa da cercare.

Brillante.

Come suggerito dal commento di zserge ,

Il legname è molto bello, ma se hai già un progetto esistente, puoi provare github.com/zserge/log. È un sostituto drop-in per android.util.Log e ha la maggior parte delle funzionalità di Timber e anche di più.

la sua libreria di log fornisce un semplice interruttore di abilitazione / disabilitazione della stampa dei log come di seguito.

Inoltre, richiede solo di cambiare le importrighe e nulla deve cambiare per l' Log.d(...);affermazione.

if (!BuildConfig.DEBUG)
    Log.usePrinter(Log.ANDROID, false); // from now on Log.d etc do nothing and is likely to be optimized with JIT

Ho migliorato la soluzione sopra fornendo supporto per diversi livelli di registro e modificando automaticamente i livelli di registro a seconda che il codice venga eseguito su un dispositivo live o sull'emulatore.

public class Log {

final static int WARN = 1;
final static int INFO = 2;
final static int DEBUG = 3;
final static int VERB = 4;

static int LOG_LEVEL;

static
{
    if ("google_sdk".equals(Build.PRODUCT) || "sdk".equals(Build.PRODUCT)) {
        LOG_LEVEL = VERB;
    } else {
        LOG_LEVEL = INFO;
    }

}


/**
 *Error
 */
public static void e(String tag, String string)
{
        android.util.Log.e(tag, string);
}

/**
 * Warn
 */
public static void w(String tag, String string)
{
        android.util.Log.w(tag, string);
}

/**
 * Info
 */
public static void i(String tag, String string)
{
    if(LOG_LEVEL >= INFO)
    {
        android.util.Log.i(tag, string);
    }
}

/**
 * Debug
 */
public static void d(String tag, String string)
{
    if(LOG_LEVEL >= DEBUG)
    {
        android.util.Log.d(tag, string);
    }
}

/**
 * Verbose
 */
public static void v(String tag, String string)
{
    if(LOG_LEVEL >= VERB)
    {
        android.util.Log.v(tag, string);
    }
}


}

ProGuard lo farà per te sulla tua build di rilascio e ora le buone notizie da android.com:

http://developer.android.com/tools/help/proguard.html

Lo strumento ProGuard riduce, ottimizza e offusca il codice rimuovendo il codice inutilizzato e rinominando classi, campi e metodi con nomi semanticamente oscuri. Il risultato è un file .apk di dimensioni inferiori che è più difficile da decodificare. Poiché ProGuard rende l'applicazione più difficile da decodificare, è importante utilizzarla quando l'applicazione utilizza funzionalità sensibili alla sicurezza, ad esempio quando si concedono in licenza le applicazioni.

ProGuard è integrato nel sistema di generazione Android, quindi non è necessario invocarlo manualmente. ProGuard viene eseguito solo quando si crea l'applicazione in modalità di rilascio, quindi non è necessario gestire il codice offuscato quando si crea l'applicazione in modalità di debug. Avere ProGuard in esecuzione è completamente opzionale, ma altamente raccomandato.

Questo documento descrive come abilitare e configurare ProGuard e come utilizzare lo strumento retrace per decodificare le tracce dello stack offuscate

Mi piace usare Log.d (TAG, alcune stringhe, spesso String.format ()).

TAG è sempre il nome della classe

Transform Log.d (TAG, -> Logd (nel testo della tua classe

private void Logd(String str){
    if (MainClass.debug) Log.d(className, str);
}

In questo modo quando sei pronto per creare una versione di rilascio, imposta MainClass.debug su false!

I log possono essere rimossi usando bash in linux e sed:

find . -name "*\.java" | xargs sed -ri ':a; s%Log\.[ivdwe].*\);%;%; ta; /Log\.[ivdwe]/ !b; N; ba'

Funziona per registri multilinea. In questa soluzione si può essere certi che i registri non sono presenti nel codice di produzione.

So che questa è una vecchia domanda, ma perché non hai sostituito tutte le tue chiamate di registro con qualcosa come booleano logCallWasHere = true; // --- resto del registro qui

Questo è il motivo per cui saprai quando vuoi rimetterli indietro e non influenzeranno la tua chiamata if statement :)

Perché non farlo

if(BuildConfig.DEBUG)
  Log.d("tag","msg");

? Non sono necessarie librerie aggiuntive, nessuna regola proguard che tende a rovinare il progetto e il compilatore java tralascerà il bytecode per questa chiamata quando si effettua il build di rilascio.

Ecco la mia soluzione se non vuoi pasticciare con librerie aggiuntive o modificare il tuo codice manualmente. Ho creato questo taccuino Jupyter per esaminare tutti i file Java e commentare tutti i messaggi di registro. Non perfetto ma ha fatto il lavoro per me.

a modo mio:

1) abilita la modalità di selezione delle colonne (alt + maiusc + insert)

2) selezionare su un Log.d (TAG, "testo"); la parte "Registro".

3) quindi sposta + ctrl + alt + j

4) fare clic sulla freccia sinistra

5) sposta + fine

6) premi cancella.

questo rimuove tutte le chiamate LOG contemporaneamente in un file java.

Puoi provare a usare questo semplice metodo convenzionale:

Ctrl+Shift +R

sostituire

Log.e(

Con

// Log.e(

Facile con kotlin, basta dichiarare alcune funzioni di alto livello

val isDebug: Boolean
    get() = BuildConfig.DEBUG

fun logE(tag: String, message: String) {
    if (isDebug) Log.e(tag, message)
}

fun logD(tag: String, message: String) {
    if (isDebug) Log.d(tag, message)
}

il modo più semplice;

uso DebugLog

Tutti i log sono disabilitati da DebugLog quando l'app viene rilasciata.

https://github.com/MustafaFerhan/DebugLog