Comment faire pour supprimer tous la journalisation du débogage des appels avant la construction de la version d'une application Android?

- Je trouver un beaucoup plus simple solution consiste à oublier tous les if vérifie tous sur la place et il suffit d'utiliser ProGuard à dépouiller toute Log.d() ou Log.v() les appels de méthode lorsque nous appelons notre Fourmi release cible.

De cette façon, nous avons toujours le debug info d'une sortie régulière construit et ne pas avoir à faire de modification de code pour la release. ProGuard pouvez également faire plusieurs passages sur le pseudo-code pour supprimer d'autres indésirables des déclarations, des blocs vides et peut automatiquement inline court méthodes, le cas échéant.

Pour exemple, voici un très de base ProGuard config pour Android:

-dontskipnonpubliclibraryclasses
-dontobfuscate
-forceprocessing
-optimizationpasses 5

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

Donc vous l'enregistrer dans un fichier, puis d'appeler ProGuard de Fourmi, de passage dans votre juste compilé POT et la plate-forme Android JAR que vous utilisez.

Voir aussi les exemples dans le ProGuard manuel.

---

Mise à jour (4,5 ans plus tard): aujourd'Hui, j'ai utilisé Bois pour Android journalisation.

Non seulement est-il un peu plus agréable que la valeur par défaut Log mise en œuvre — le journal de la balise est définie automatiquement, et il est facile de journal formaté des chaînes et des exceptions, mais vous pouvez également spécifier différentes journalisation des comportements lors de l'exécution.

Dans cet exemple, l'enregistrement des déclarations ne seront écrites à logcat dans les versions de débogage de mon application:

Bois est mis en place dans mon Application onCreate() méthode:

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

Puis n'importe où ailleurs dans mon code je peux me connecter facilement:

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

Voir le Bois d'exemple d'application pour un exemple plus complexe, où toutes les instructions sont envoyées à logcat au cours du développement et en production, aucune des instructions de débogage sont enregistrés, mais les erreurs sont silencieusement signalé à Crashlytics.

Je suggère d'avoir un static boolean quelque part indiquant si oui ou non pour vous connecter:

classe MyDebug { 
static final boolean LOG = true; 
} 

Alors, où que vous souhaitez vous connecter dans votre code, il suffit de faire ceci:

si (MyDebug.JOURNAL) { 
si (condition) Journal.je(...); 
} 

Maintenant, lorsque vous définissez MyDebug.JOURNAL des faux, le compilateur va foirer tout le code à l'intérieur de ces contrôles (car c'est un statique de la finale, elle sait au moment de la compilation que le code n'est pas utilisé.)

Pour les grands projets, vous pouvez commencer à avoir des booléens dans des fichiers individuels à être en mesure de facilement activer ou désactiver la journalisation là en tant que de besoin. Par exemple, ce sont les différents journalisation des constantes que nous avons dans le gestionnaire de fenêtre:

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;

Avec code correspondant comme:

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

Je voudrais ajouter quelques précisions sur l'utilisation de Proguard avec Android Studio et gradle, depuis que j'ai eu beaucoup de problèmes pour supprimer les lignes du journal de la finale binaire.

Afin de rendre assumenosideeffects dans Proguard fonctionne, il est une condition préalable.

Dans votre gradle fichier, vous devez spécifier l'utilisation de la proguard-android-optimize.txt comme fichier par défaut.

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'
    }
}

En fait, par défaut dans le proguard-android.txt fichier, l'optimisation est désactivé avec les deux drapeaux:

-dontoptimize
-dontpreverify

La proguard-android-optimize.txt fichier ne pas ajouter ces lignes, alors maintenant assumenosideeffects peut travailler.

Puis, personnellement, j'utilise SLF4J, d'autant plus quand je développe un certain nombre de bibliothèques qui sont distribués à d'autres. L'avantage est que par défaut il n'y a pas de sortie. Et si l'intégrateur veut certains journal des sorties, il peut utilise Logback pour Android et activez les logs, donc, les journaux peuvent être redirigé vers un fichier ou de le LogCat.

Si j'ai vraiment besoin de dépouiller les journaux de la finale de la bibliothèque, je puis ajouter à mon Proguard fichier (après avoir activé le proguard-android-optimize.txt fichier de cours):

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

J'ai utilisé un LogUtils classe comme dans la Google IO exemple d'application. Je l'ai modifié pour utiliser une application spécifique de DÉBOGAGE constante au lieu de BuildConfig.DEBUG car BuildConfig.DEBUG n'est pas fiable. Ensuite, dans mes Classes, j'ai suivantes.

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

Je poste cette solution qui s'applique spécifiquement pour Android Studio utilisateurs. J'ai aussi récemment découvert Bois et ont importé avec succès dans mon application en procédant comme suit:

Mettre la dernière version de la bibliothèque dans votre build.gradle:

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

Puis dans Android Studios, allez dans Edit -> Find -> Remplacez le Chemin d'accès...

Type dans Log.e(TAG, ou cependant vous avez défini vos messages de Log dans le "Text to find" zone de texte. Alors que vous venez de le remplacer par Timber.e(

Cliquez sur Rechercher, puis sur remplacer tout.

Android Studios allons maintenant passer en revue tous les fichiers dans votre projet et de le remplacer tous les Journaux avec des Poutres.

Le seul problème que j'ai eu avec cette méthode est que gradle ne viennent avec un million de messages d'erreur par la suite car il ne peut pas trouver de "Bois" dans les importations pour chacun de vos fichiers java. Cliquez simplement sur les erreurs et Android Studios sera automatiquement importer "Bois de construction" en java. Une fois que vous l'avez fait pour l'ensemble de vos erreurs de fichiers, gradle de compiler à nouveau.

Vous avez également besoin de mettre ce bout de code dans votre onCreate méthode de votre Application classe:

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

Cela se traduira par l'application de journalisation uniquement lorsque vous êtes en mode de développement non en production. Vous pouvez également avoir BuildConfig.RELEASE pour l'enregistrement en mode release.

Si vous pouvez courir un remplacement global (une fois), et après que conserver quelques-uns convention de codage, vous pouvez suivre le modèle souvent utilisé dans Android cadre.

Au lieu d'écrire

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

avoir comme

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

Maintenant proguard pouvez supprimer le StringBuilder et toutes les chaînes et les méthodes qu'il utilise sur le chemin, à partir de la version optimisée de DEX. Utilisation proguard-android-optimize.txt et vous n'avez pas besoin de vous soucier de android.util.Journal dans votre proguard-rules.pro:

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

Avec Android Studio plugin gradle, BuildConfig.DEBUG est tout à fait fiables, de sorte que vous n'avez pas besoin de constantes pour contrôler le décapage.

Comme zserge commentaire suggéré,

Bois est très agréable, mais si vous avez déjà un projet existant, vous pouvez essayer github.com/zserge/log . C'est une baisse-dans le remplacement pour android.util.Journal et a plus de fonctionnalités que le Bois a et même plus.

son journal de la bibliothèque est facile à activer/désactiver le journal de l'impression de basculer comme ci-dessous.

En outre, il seulement doit changer de import lignes, et rien doit changer pour Log.d(...); déclaration.

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

C'est ce que j'ai utilisé pour faire mon android projets..

Dans Android Studio, on peut faire la même opération par Ctrl+Shift+F pour rechercher de l'ensemble du projet (Commande+Maj+F sous MacOs) et Ctrl+Maj+R pour Remplacer ((Commande+Maj+R MacOs))

ProGuard le fera pour vous sur votre communiqué de construire et maintenant, la bonne nouvelle de android.com:

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

Le ProGuard outil se rétrécit, optimise et dissimule votre code en supprimant code inutilisé, et de le renommer les classes, les champs et les méthodes du point de vue sémantique obscur noms. Le résultat est une taille plus petite .fichier apk qui est plus difficile à déjouer. Parce que ProGuard permet à votre application de plus difficile à désosser, il est important que vous l'utilisez lorsque votre application utilise des fonctionnalités qui sont sensibles à la sécurité, comme lorsque vous êtes à la Licence de Vos Applications.

ProGuard est intégré dans l'Android de construction du système, de sorte que vous n'avez pas à appeler manuellement. ProGuard s'exécute uniquement lorsque vous générez votre application en mode de diffusion, de sorte que vous n'avez pas à traiter avec d'obfuscation de code lorsque vous générez votre application en mode debug. Ayant ProGuard run est totalement facultatif, mais fortement recommandé.

Ce document décrit comment activer et configurer ProGuard ainsi que l'utilisation de la retracer outil pour décoder dissimulé les traces de pile

Les journaux peuvent être retirés à l'aide de bash sous linux et sed:

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

Travaille pour plusieurs lignes de logs. Dans cette solution, vous pouvez être sûr, que les journaux ne sont pas présents dans le code de production.

Pourquoi ne pas

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

? Pas de bibliothèques supplémentaires, pas de proguard règles qui tendent à vis du projet et de java, le compilateur va juste laisser bytecode pour pour cet appel lorsque vous effectuez une version validée.