Как удалить все вызовы журнала отладки перед созданием релизной версии приложения для Android?

Я считаю, что гораздо более простое решение - забыть обо всех if проверках повсюду и просто использовать ProGuard, чтобы избавиться от них. любые Log.d() или Log.v() вызовы методов, когда мы вызываем нашу цель Ant release.

Таким образом, у нас всегда есть отладочная информация, выводимая для обычных сборок, и нам не нужно вносить какие-либо изменения в код для сборок выпуска. ProGuard также может выполнять несколько проходов по байт-коду для удаления других нежелательных операторов, пустых блоков и может автоматически встраивать короткие методы, где это необходимо.

Например, вот очень простая конфигурация ProGuard для Android:

-dontskipnonpubliclibraryclasses
-dontobfuscate
-forceprocessing
-optimizationpasses 5

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

Таким образом, вы должны сохранить это в файл, а затем вызвать ProGuard из Ant, передав свой только что скомпилированный JAR и JAR-файл платформы Android, который вы используете.

См. Также примеры в руководстве ProGuard.

Обновление (спустя 4,5 года): в настоящее время я использую Timber для ведения журнала Android.

Это не только немного лучше, чем реализация по умолчанию Log - тег журнала устанавливается автоматически, и в него легко записывать отформатированные строки и исключения - но вы также можете указать другое поведение ведения журнала во время выполнения.

В этом примере операторы ведения журнала будут записаны в logcat только в отладочных сборках моего приложения:

Древесина настраивается моим Application onCreate() методом:

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

Тогда где-нибудь еще в моем коде я могу легко войти:

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

См. Древесина sample app для более сложного примера, где все операторы журнала отправляются в logcat во время разработки, а в производственной среде операторы отладки не регистрируются, но сообщения об ошибках автоматически передаются в Crashlytics.

Все хорошие ответы, но когда я закончил разработку, я не хотел ни использовать операторы if для всех вызовов журнала, ни использовать внешние инструменты.

Итак, решение, которое я использую, - заменить класс android.util.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);
    }
}

Единственное, что мне нужно было сделать во всех исходных файлах, - это заменить импорт android.util.Log моим собственным классом.

Я предлагаю иметь где-нибудь статическое логическое значение, указывающее, нужно ли регистрировать:

class MyDebug {
  static final boolean LOG = true;
}

Затем, где бы вы ни хотели войти в свой код, просто сделайте это:

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

Теперь, когда вы устанавливаете MyDebug.LOG в false, компилятор удаляет весь код внутри таких проверок (поскольку это статический финал, он знает во время компиляции, что код не используется).

Для более крупных проектов вы можете захотеть иметь логические значения в отдельных файлах, чтобы иметь возможность легко включать или отключать ведение журнала по мере необходимости. Например, это различные константы журналирования, которые есть в оконном менеджере:

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;

С соответствующим кодом, например:

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

Решение Proguard от Кристофера - лучшее, но если по какой-либо причине вам не нравится Proguard, вот очень низкотехнологичное решение:

Журналы комментариев:

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

Раскомментировать журналы:

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

Ограничением является то, что ваши инструкции по ведению журнала не должны занимать несколько строк.

(Выполните эти строки в оболочке UNIX в корне вашего проекта. При использовании Windows получите уровень UNIX или используйте эквивалентные команды Windows)

Я хотел бы внести некоторые уточнения в использование Proguard с Android Studio и gradle, поскольку у меня было много проблем с удалением строк журнала из окончательного двоичного файла.

Для того, чтобы assumenosideeffects в Proguard работал, есть необходимое условие.

В вашем файле gradle вы должны указать использование proguard-android-optimize.txt в качестве файла по умолчанию.

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

Фактически, в файле proguard-android.txt по умолчанию оптимизация отключена двумя флагами:

-dontoptimize
-dontpreverify

Файл proguard-android-optimize.txt не добавляет эти строки, поэтому теперь assumenosideeffects может работать.

Затем лично я использую SLF4J, тем более, что разрабатываю одни библиотеки, которые распространяются среди других. Преимущество в том, что по умолчанию нет вывода. А если интегратору нужны выходные данные журнала, он может использовать Logback для Android и активировать журналы, чтобы журналы можно было перенаправить в файл или в LogCat.

Если мне действительно нужно удалить журналы из последней библиотеки, я добавляю в свой файл Proguard (конечно, после включения файла proguard-android-optimize.txt):

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

Я настоятельно рекомендую использовать Timber от Jake Wharton

https://github.com/JakeWharton/timber

он решает вашу проблему с включением / отключением плюс автоматически добавляет класс тега

просто

public class MyApp extends Application {

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

журналы будут использоваться только в вашей отладочной версии, а затем используйте

Timber.d("lol");

or

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

печатать

"Ваш класс / сообщение" без указания тега

Я использовал LogUtils, как в примере приложения Google IO. Я изменил это, чтобы использовать константу DEBUG для конкретного приложения вместо BuildConfig.DEBUG, потому что BuildConfig .DEBUG ненадежен. Тогда в моих классах у меня есть следующее.

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

Я бы подумал об использовании средства ведения журнала roboguice вместо встроенного android.util. Бревно

Их средство автоматически отключает журналы отладки и подробные журналы для сборок выпуска. Кроме того, вы получаете несколько отличных функций бесплатно (например, настраиваемое поведение журнала, дополнительные данные для каждого журнала и многое другое).

Использование proguard может быть довольно проблематичным, и я бы не стал беспокоиться о настройке и настройке его работы с вашим приложением, если у вас нет для этого веской причины (отключение журналов - не лучший вариант).

Я публикую это решение, которое применяется специально для пользователей Android Studio. Я также недавно обнаружил Timber и успешно импортировал его в свое приложение, выполнив следующие действия:

Поместите последнюю версию библиотеки в свой build.gradle:

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

Затем в Android Studios перейдите в Edit -> Find -> Replace in Path ...

Введите Log.e(TAG, или, как бы то ни было, вы определили сообщения журнала в текстовое поле "Text to find". Затем просто замените его на Timber.e(

Нажмите «Найти», а затем замените все.

Android Studios теперь просмотрит все ваши файлы в вашем проекте и заменит все журналы на Timbers.

Единственная проблема, с которой я столкнулся с этим методом, заключается в том, что gradle после этого выдает миллион сообщений об ошибках, потому что он не может найти «Timber» в импорте для каждого из ваших java-файлов. Просто нажмите на ошибку, и Android Studios автоматически импортирует "Timber" в ваш java. Как только вы сделаете это для всех файлов ошибок, gradle снова скомпилируется.

Вам также необходимо поместить этот фрагмент кода в свой onCreate метод вашего Application класса:

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

Это приведет к ведению журнала приложения только тогда, когда вы находитесь в режиме разработки, а не в производстве. Вы также можете использовать BuildConfig.RELEASE для входа в режим выпуска.

Per android.util.Log предоставляет способ включить / отключить журнал:

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

По умолчанию метод isLoggable (...) возвращает false, только после того, как вы установили параметр на устройстве, как это:

adb shell setprop log.tag.MyAppTag DEBUG

Это означает, что любой журнал выше уровня DEBUG можно распечатать. Справочная документация по Android:

Проверяет, доступен ли журнал для указанного тега на указанном уровне. Уровень по умолчанию для любого тега установлен на INFO. Это означает, что будет регистрироваться любой уровень выше, включая ИНФОРМАЦИЮ. Перед тем, как делать какие-либо вызовы метода ведения журнала, вы должны проверить, должен ли ваш тег регистрироваться. Вы можете изменить уровень по умолчанию, установив системное свойство: 'setprop log.tag. 'Где level - это VERBOSE, DEBUG, INFO, WARN, ERROR, ASSERT или SUPPRESS. SUPPRESS отключит все журналы для вашего тега. Вы также можете создать файл local.prop со следующим содержимым: 'log.tag. =' И поместить его в /data/local.prop.

Итак, мы могли бы использовать настраиваемую утилиту журнала:

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

Если вы можете выполнить глобальную замену (один раз) и после этого сохранить некоторые соглашения о кодировании, вы можете следовать шаблону, часто используемому в Android framework.

Вместо того, чтобы писать

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

иметь это как

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

Теперь proguard может удалить StringBuilder, а также все строки и методы, которые он использует в пути, из оптимизированного выпуска DEX. Используйте proguard-android-optimize.txt, и вам не нужно беспокоиться о android.util.Log в вашем proguard-rules.pro:

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

С плагином Android Studio gradle BuildConfig.DEBUG достаточно надежен, поэтому вам не нужны дополнительные константы для управления зачисткой.

Добавьте следующее в файл proguard-rules.txt

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

У меня есть очень простое решение. Я использую IntelliJ для разработки, поэтому детали различаются, но идея должна применяться во всех IDE.

Я выбираю корень своего исходного дерева, щелкаю правой кнопкой мыши и выбираю «заменить». Затем я решаю заменить все «Журнал». с «// Журнал.». Это удаляет все операторы журнала. Чтобы вернуть их позже, я повторяю ту же замену, но на этот раз заменяю все «// Журнал». с "Журнал".

Просто отлично работает для меня. Просто не забудьте установить замену как чувствительную к регистру, чтобы избежать несчастных случаев, таких как «Диалог.». Для дополнительной уверенности вы также можете сделать первый шаг с помощью «Журнала». в качестве строки для поиска.

Блестяще.

Как комментарий zserge предложено,

Древесина очень хороша, но если у вас уже есть существующий проект - вы можете попробовать github.com/zserge/log. Это прямая замена android.util.Log и имеет большинство функций, которые есть в Timber, и даже больше.

его библиотека журналов предоставляет простой переключатель включения / отключения печати журналов, как показано ниже.

Кроме того, для него только требуется изменить import строки, а ничего не нужно менять для оператора Log.d(...);.

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

Это то, что я делал в своих проектах для Android ..

В Android Studio мы можем выполнить аналогичную операцию с помощью Ctrl + Shift + F, чтобы найти из всего проекта (Command + Shift + F в MacOs) и Ctrl + Shift + R, чтобы заменить ((Command + Shift + R в MacOs))

Я улучшил вышеприведенное решение, предоставив поддержку различных уровней журналов и автоматически изменив уровни журналов в зависимости от того, выполняется ли код на действующем устройстве или на эмуляторе.

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 сделает это за вас при выпуске вашего релиза, а теперь хорошие новости от android.com:

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

Инструмент ProGuard сжимает, оптимизирует и скрывает ваш код, удаляя неиспользуемый код и переименовывая классы, поля и методы с семантически непонятными именами. В результате получается файл .apk меньшего размера, который труднее реконструировать. Поскольку ProGuard затрудняет обратное проектирование вашего приложения, важно, чтобы вы использовали его, когда ваше приложение использует функции, чувствительные к безопасности, например, когда вы лицензируете свои приложения.

ProGuard интегрирован в систему сборки Android, поэтому вам не нужно вызывать его вручную. ProGuard запускается только при сборке приложения в режиме выпуска, поэтому вам не нужно иметь дело с запутанным кодом при сборке приложения в режиме отладки. Запуск ProGuard не является обязательным, но настоятельно рекомендуется.

В этом документе описывается, как включить и настроить ProGuard, а также использовать инструмент восстановления для декодирования запутанных трассировок стека.

Вот как я решаю это в моем проекте Kotlin перед запуском в производство:

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

-assumenosideeffects class android.util.Log {
    public static boolean isLoggable(java.lang.String, int);
    public static int d(...);
    public static int w(...);
    public static int v(...);
    public static int i(...);
    public static int e(...);
}

Мне нравится использовать Log.d (TAG, некоторая строка, часто String.format ()).

TAG - это всегда имя класса

Преобразовать Log.d (TAG, -> Logd (в тексте вашего класса

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

Таким образом, когда вы будете готовы сделать релизную версию, установите для MainClass.debug значение false!

Журналы можно удалить с помощью bash в linux и sed:

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

Работает для многострочных журналов. В этом решении вы можете быть уверены, что журналы отсутствуют в производственном коде.

Я знаю, что это старый вопрос, но почему вы не заменили все вызовы журнала чем-то вроде логического logCallWasHere = true; // --- остальная часть вашего журнала здесь

Вот почему вы будете знать, когда захотите вернуть их, и они не повлияют на ваш вызов оператора if :)

Почему бы просто не сделать

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

? Никаких дополнительных библиотек не требуется, никаких правил proguard, которые могут испортить проект, а компилятор java просто оставит байт-код для этого вызова, когда вы сделаете сборку релиза.

Вот мое решение, если вы не хотите возиться с дополнительными библиотеками или редактировать код вручную. Я создал эту записную книжку Jupyter, чтобы просмотреть все файлы java и закомментировать все сообщения журнала. Не идеально, но он сделал свою работу за меня.

мой метод:

1) включить режим выбора столбца (alt + shift + insert)

2) выделить по одному Log.d (TAG, «текст»); часть «Журнал».

3) затем нажмите shift + ctrl + alt + j

4) щелкните стрелку влево

5) делать shift + end

6) нажмите удалить.

это удаляет сразу все вызовы LOG в файле java.

С kotlin легко, просто объявите несколько функций верхнего уровня

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

Если вы хотите использовать программный подход вместо использования ProGuard, то, создав свой собственный класс с двумя экземплярами, один для отладки, а другой для выпуска, вы можете выбрать, что для входа в систему в любом случае.

Итак, если вы не хотите ничего регистрировать в выпуске, просто реализуйте Logger, который ничего не делает, как в примере ниже:

import android.util.Log

sealed class Logger(defaultTag: String? = null) {
    protected val defaultTag: String = defaultTag ?: "[APP-DEBUG]"

    abstract fun log(string: String, tag: String = defaultTag)

    object LoggerDebug : Logger() {
        override fun log(string: String, tag: String) {
            Log.d(tag, string)
        }
    }

    object LoggerRelease : Logger() {
        override fun log(string: String, tag: String) {}
    }

    companion object {
        private val isDebugConfig = BuildConfig.DEBUG

        val instance: Logger by lazy {
            if(isDebugConfig)
            LoggerDebug
            else
                LoggerRelease
        }

    }
}

Затем, чтобы использовать свой класс регистратора:

class MainActivity : AppCompatActivity() {

private val logger = Logger.instance

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    logger.log("Activity launched...")
    ...
    myView.setOnClickListener {
        ...

        logger.log("My View clicked!", "View-click")
    }
}

== ОБНОВЛЕНИЕ ==

Если мы хотим избежать конкатенации строк для повышения производительности, мы можем добавить встроенную функцию с лямбдой, которая будет вызываться только в конфигурации отладки:

// Add this function to the Logger class.
inline fun commit(block: Logger.() -> Unit) {
    if(this is LoggerDebug)
        block.invoke(this)
}

А потом:

 logger.commit {
     log("Logging without $myVar waste of resources"+ "My fancy concat")
 }

Поскольку мы используем встроенную функцию, нет дополнительных выделений объектов и дополнительных вызовов виртуальных методов.

самый простой способ;

используйте 1_

Все журналы отключаются DebugLog при выпуске приложения.

https://github.com/MustafaFerhan/DebugLog

Вы можете попробовать воспользоваться этим простым обычным методом:

Ctrl + Shift + R

заменять

Log.e(

С участием

// Log.e(