Bagaimana cara menghapus semua panggilan debug logging sebelum membangun versi rilis aplikasi Android?

Menurut Google, saya harus " menonaktifkan panggilan ke metode Log dalam kode sumber " sebelum menerbitkan aplikasi Android saya ke Google Play. Ekstrak dari bagian 3 daftar periksa publikasi :

Pastikan Anda menonaktifkan logging dan menonaktifkan opsi debugging sebelum Anda membangun aplikasi Anda untuk rilis. Anda dapat menonaktifkan logging dengan menghapus panggilan ke metode Log dalam file sumber Anda.

Proyek open-source saya besar dan sulit melakukannya secara manual setiap kali saya merilis. Selain itu, menghapus baris Log berpotensi rumit, misalnya:

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

Jika saya mengomentari baris Log, maka ketentuannya berlaku untuk baris berikutnya, dan kemungkinan dimuat () tidak dipanggil. Apakah situasi seperti itu cukup langka sehingga saya dapat memutuskan bahwa seharusnya tidak ada?

Jadi, apakah ada cara tingkat kode sumber yang lebih baik untuk melakukan itu? Atau mungkin beberapa sintaks ProGuard pintar untuk menghapus semua baris Log secara efisien tapi aman?

Saya menemukan solusi yang jauh lebih mudah adalah dengan melupakan semua ifcek di semua tempat dan cukup gunakan ProGuard untuk menghapus panggilan metode Log.d()atau apa pun Log.v()ketika kita memanggil releasetarget Ant .

Dengan begitu, kami selalu memiliki info debug yang menjadi keluaran untuk build reguler dan tidak harus membuat perubahan kode untuk build rilis. ProGuard juga dapat melakukan beberapa lintasan melewati kode byte untuk menghapus pernyataan yang tidak diinginkan lainnya, blok kosong dan secara otomatis dapat inline metode pendek jika diperlukan.

Sebagai contoh, berikut ini adalah konfigurasi ProGuard yang sangat mendasar untuk Android:

-dontskipnonpubliclibraryclasses
-dontobfuscate
-forceprocessing
-optimizationpasses 5

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

Jadi Anda akan menyimpannya di file, lalu panggil ProGuard dari Ant, dengan mengirimkan JAR yang baru dikompilasi dan platform Android JAR yang Anda gunakan.

Lihat juga contoh-contoh dalam manual ProGuard.

Pembaruan (4,5 tahun kemudian): Saat ini saya menggunakan Kayu untuk Android logging.

Tidak hanya itu sedikit lebih bagus daripada yang standar Log implementasi - tag log diatur secara otomatis, dan mudah untuk mencatat string dan pengecualian yang diformat - tetapi Anda juga dapat menentukan perilaku pencatatan yang berbeda saat runtime.

Dalam contoh ini, pernyataan logging hanya akan ditulis ke logcat di build debug aplikasi saya:

Kayu diatur dalam Application onCreate()metode saya :

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

Kemudian di tempat lain dalam kode saya, saya bisa login dengan mudah:

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

Lihat contoh aplikasi Kayu untuk contoh lebih lanjut, di mana semua laporan log dikirim ke logcat selama pengembangan dan, dalam produksi, tidak ada laporan debug dicatat, tetapi kesalahan dilaporkan secara diam-diam ke Crashlytics.

Semua jawaban yang baik, tetapi ketika saya selesai dengan pengembangan saya, saya tidak ingin menggunakan apakah pernyataan di sekitar semua panggilan Log, juga tidak ingin menggunakan alat eksternal.

Jadi solusi yang saya gunakan adalah mengganti kelas android.util.Log dengan kelas Log saya sendiri:

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

Satu-satunya hal yang harus saya lakukan di semua file sumber adalah mengganti impor android.util.Log dengan kelas saya sendiri.

Saya sarankan memiliki boolean statis di suatu tempat yang menunjukkan apakah akan masuk atau tidak:

class MyDebug {
  LOG boolean akhir statis = true;
}

Lalu di mana pun Anda ingin masuk kode Anda, lakukan saja ini:

if (MyDebug.LOG) {
  jika (kondisi) Log.i (...);
}

Sekarang ketika Anda mengatur MyDebug.LOG ke false, kompiler akan menghapus semua kode di dalam pemeriksaan tersebut (karena ini adalah final statis, ia tahu pada waktu kompilasi kode itu tidak digunakan.)

Untuk proyek yang lebih besar, Anda mungkin ingin mulai memiliki boolean dalam file individual untuk dapat dengan mudah mengaktifkan atau menonaktifkan pencatatan yang diperlukan. Misalnya, ini adalah berbagai konstanta logging yang kita miliki di window manager:

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;

Dengan kode yang sesuai seperti:

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

Solusi Christopher Proguard adalah yang terbaik, tetapi jika karena alasan apa pun Anda tidak menyukai Proguard, berikut adalah solusi yang sangat berteknologi rendah:

Log komentar:

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

Log tanda komentar:

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

Kendala adalah bahwa instruksi logging Anda tidak boleh menjangkau lebih dari beberapa baris.

(Jalankan baris ini dalam shell UNIX di root proyek Anda. Jika menggunakan Windows, dapatkan layer UNIX atau gunakan perintah Windows yang setara)

Saya ingin menambahkan beberapa prasyarat tentang penggunaan Proguard dengan Android Studio dan gradle, karena saya punya banyak masalah untuk menghapus baris log dari biner terakhir.

Untuk membuat assumenosideeffectskarya Proguard, ada prasyarat.

Di file gradle Anda, Anda harus menentukan penggunaan proguard-android-optimize.txtfile sebagai default.

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

Sebenarnya, dalam proguard-android.txtfile default , optimisasi dinonaktifkan dengan dua flag:

-dontoptimize
-dontpreverify

The proguard-android-optimize.txtfile tidak menambahkan garis, jadi sekarang assumenosideeffectsbisa bekerja.

Kemudian, secara pribadi, saya menggunakan SLF4J , ketika saya mengembangkan beberapa perpustakaan yang didistribusikan kepada orang lain. Keuntungannya adalah secara default tidak ada output. Dan jika integrator menginginkan beberapa output log, ia dapat menggunakan Logback untuk Android dan mengaktifkan log, sehingga log dapat dialihkan ke file atau ke LogCat.

Jika saya benar-benar perlu menghapus log dari perpustakaan terakhir, saya kemudian menambahkan ke file Proguard saya (setelah mengaktifkan proguard-android-optimize.txtfile tentu saja):

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

Saya sangat menyarankan menggunakan Kayu dari Jake Wharton

https://github.com/JakeWharton/timber

itu memecahkan masalah Anda dengan mengaktifkan / menonaktifkan ditambah menambahkan kelas tag secara otomatis

hanya

public class MyApp extends Application {

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

log hanya akan digunakan di versi debug Anda, dan kemudian gunakan

Timber.d("lol");

atau

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

untuk mencetak

"Kelas Anda / msg" tanpa menentukan tag

Saya telah menggunakan kelas LogUtils seperti pada aplikasi contoh Google IO. Saya memodifikasi ini untuk menggunakan aplikasi DEBUG konstan tertentu, bukan BuildConfig.DEBUG karena BuildConfig.DEBUG tidak dapat diandalkan . Kemudian di Kelas saya, saya memiliki yang berikut ini.

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

Saya akan mempertimbangkan menggunakan fasilitas logging roboguice alih-alih android.util.Log bawaan

Fasilitas mereka secara otomatis menonaktifkan debug dan verbose log untuk rilis rilis. Plus, Anda mendapatkan beberapa fitur bagus secara gratis (misalnya perilaku logging yang dapat disesuaikan, data tambahan untuk setiap log, dan lainnya)

Menggunakan proguard bisa sangat merepotkan dan saya tidak akan mengalami kesulitan mengkonfigurasi dan membuatnya berfungsi dengan aplikasi Anda kecuali Anda memiliki alasan yang bagus untuk itu (menonaktifkan log bukan yang baik)

Saya memposting solusi ini yang berlaku khusus untuk pengguna Android Studio. Saya juga baru-baru ini menemukan Timber dan berhasil mengimpornya ke aplikasi saya dengan melakukan hal berikut:

Masukkan versi terbaru perpustakaan ke build.gradle Anda:

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

Kemudian di Android Studios, buka Edit -> Find -> Replace in Path ...

Ketik Log.e(TAG,atau bagaimanapun Anda telah menetapkan pesan Log ke dalam "Text to find"kotak teks. Maka Anda tinggal menggantinya denganTimber.e(

Klik Temukan dan ganti semua.

Android Studios sekarang akan memeriksa semua file Anda di proyek Anda dan mengganti semua Log dengan Timbers.

Satu-satunya masalah yang saya miliki dengan metode ini adalah gradle muncul dengan sejuta pesan kesalahan setelah itu karena tidak dapat menemukan "Kayu" dalam impor untuk setiap file java Anda. Cukup klik pada kesalahan dan Android Studios akan secara otomatis mengimpor "Kayu" ke java Anda. Setelah Anda selesai melakukannya untuk semua file kesalahan, gradle akan dikompilasi lagi.

Anda juga perlu memasukkan kode ini ke onCreatemetode Applicationkelas Anda :

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

Ini akan menghasilkan pendataan aplikasi hanya ketika Anda berada dalam mode pengembangan tidak dalam produksi. Anda juga dapat memiliki BuildConfig.RELEASEuntuk masuk dalam mode rilis.

Per android.util.Log menyediakan cara untuk mengaktifkan / menonaktifkan log:

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

Default metode ini adalahLoggable (...) mengembalikan false, hanya setelah Anda setprop di perangkat suka ini:

adb shell setprop log.tag.MyAppTag DEBUG

Ini berarti setiap log di atas level DEBUG dapat dicetak. Referensi dokumen android:

Cek untuk melihat apakah log untuk tag yang ditentukan dapat loggable pada tingkat yang ditentukan. Level default setiap tag diatur ke INFO. Ini berarti bahwa setiap level di atas dan termasuk INFO akan dicatat. Sebelum Anda melakukan panggilan ke metode logging, Anda harus memeriksa untuk melihat apakah tag Anda harus dicatat. Anda dapat mengubah level default dengan menyetel properti sistem: 'setprop log.tag. 'Di mana level adalah VERBOSE, DEBUG, INFO, WARN, ERROR, ASSERT, atau SUPPRESS. SUPPRESS akan mematikan semua logging untuk tag Anda. Anda juga dapat membuat file local.prop dengan yang berikut ini di dalamnya: 'log.tag. =' Dan tempatkan di /data/local.prop.

Jadi kita bisa menggunakan util log kustom:

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

Jika Anda dapat menjalankan penggantian global (sekali), dan setelah itu mempertahankan beberapa konvensi pengkodean, Anda dapat mengikuti pola yang sering digunakan dalam kerangka kerja Android .

Alih-alih menulis

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

memilikinya sebagai

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

Sekarang proguard dapat menghapus StringBuilder dan semua string dan metode yang digunakannya, dari rilis DEX yang dioptimalkan. Gunakan proguard-android-optimize.txtdan Anda tidak perlu khawatir tentang android.util.Log di proguard-rules.pro:

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

Dengan plugin Android Studio gradle, cukup dapat diandalkan, sehingga Anda tidak perlu konstanta tambahan untuk mengontrol stripping.BuildConfig.DEBUG

Tambahkan berikut ini ke file proguard-rules.txt Anda

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

Ini adalah apa yang saya lakukan pada proyek android saya ..

Di Android Studio kita dapat melakukan operasi serupa dengan, Ctrl + Shift + F untuk mencari dari seluruh proyek (Command + Shift + F di MacOs) dan Ctrl + Shift + R untuk Ganti ((Command + Shift + R di MacOs))

Saya punya solusi yang sangat sederhana. Saya menggunakan IntelliJ untuk pengembangan, jadi detailnya berbeda-beda, tetapi idenya harus berlaku di semua IDE.

Saya memilih untuk me-root pohon sumber saya, klik kanan dan pilih untuk melakukan "ganti". Saya kemudian memilih untuk mengganti semua "Log." dengan "// Log.". Ini menghapus semua pernyataan log. Untuk mengembalikannya nanti saya ulangi penggantian yang sama tetapi kali ini ganti semua "// Log." dengan "Log.".

Bekerja sangat bagus untuk saya. Hanya ingat untuk mengatur penggantian sebagai case sensitif untuk menghindari kecelakaan seperti "Dialog." Untuk jaminan tambahan, Anda juga dapat melakukan langkah pertama dengan "Log." sebagai string untuk mencari.

Cemerlang.

Seperti yang disarankan komentar zserge ,

Kayu sangat bagus, tetapi jika Anda sudah memiliki proyek yang ada - Anda dapat mencoba github.com/zserge/log. Ini adalah pengganti drop-in untuk android.util.Log dan memiliki sebagian besar fitur yang dimiliki Timber dan bahkan lebih.

perpustakaan log-nya menyediakan sakelar aktifkan / nonaktifkan pencetakan log sederhana seperti di bawah ini.

Selain itu, hanya perlu mengubah importbaris, dan tidak perlu mengubah Log.d(...);pernyataan.

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

Saya telah meningkatkan solusi di atas dengan memberikan dukungan untuk level log yang berbeda dan dengan mengubah level log secara otomatis tergantung pada apakah kode tersebut dijalankan pada perangkat langsung atau pada emulator.

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 akan melakukannya untuk Anda pada rilis rilis Anda dan sekarang kabar baik dari android.com:

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

Alat ProGuard menyusut, mengoptimalkan, dan mengaburkan kode Anda dengan menghapus kode yang tidak digunakan dan mengganti nama kelas, bidang, dan metode dengan nama yang secara semantik tidak jelas. Hasilnya adalah file .apk berukuran lebih kecil yang lebih sulit untuk dibalik. Karena ProGuard membuat aplikasi Anda lebih sulit untuk direkayasa ulang, penting bagi Anda untuk menggunakannya saat aplikasi Anda menggunakan fitur yang sensitif terhadap keamanan seperti ketika Anda Melisensikan Aplikasi Anda.

ProGuard terintegrasi ke dalam sistem build Android, jadi Anda tidak perlu memintanya secara manual. ProGuard hanya berjalan ketika Anda membangun aplikasi dalam mode rilis, jadi Anda tidak harus berurusan dengan kode yang dikaburkan ketika Anda membangun aplikasi dalam mode debug. Menjalankan ProGuard sepenuhnya opsional, tetapi sangat disarankan.

Dokumen ini menjelaskan cara mengaktifkan dan mengkonfigurasi ProGuard serta menggunakan alat retrace untuk memecahkan kode jejak tumpukan yang dikaburkan

Saya suka menggunakan Log.d (TAG, beberapa string, seringkali sebuah String.format ()).

TAG selalu merupakan nama kelas

Transform Log.d (TAG, -> Logd (dalam teks kelas Anda

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

Dengan cara ini ketika Anda siap untuk membuat versi rilis, atur MainClass.debug ke false!

Log dapat dihapus menggunakan bash di linux dan sed:

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

Bekerja untuk log multiline. Dalam solusi ini Anda dapat yakin, bahwa log tidak ada dalam kode produksi.

Saya tahu ini adalah pertanyaan lama, tetapi mengapa Anda tidak mengganti semua panggilan log Anda dengan sesuatu seperti Boolean logCallWasHere = true; // --- sisa log Anda di sini

Ini sebabnya Anda akan tahu kapan Anda ingin mengembalikannya, dan mereka tidak akan memengaruhi panggilan pernyataan if Anda :)

Kenapa tidak lakukan saja

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

? Tidak diperlukan pustaka tambahan, tidak ada aturan proguard yang cenderung mengacaukan proyek dan kompiler java hanya akan meninggalkan bytecode untuk panggilan ini ketika Anda membuat rilis build.

Ini solusi saya jika Anda tidak ingin mengacaukan dengan perpustakaan tambahan atau mengedit kode Anda secara manual. Saya membuat notebook Jupyter ini untuk membahas semua file java dan mengomentari semua pesan Log. Tidak sempurna tetapi itu menyelesaikan pekerjaan untuk saya.

jalanku:

1) aktifkan Mode Pemilihan Kolom (alt + shift + insert)

2) pilih satu Log.d (TAG, "text"); bagian 'Log.'

3) kemudian lakukan shift + ctrl + alt + j

4) klik panah kiri

5) lakukan shift + end

6) tekan delete.

ini menghapus semua panggilan LOG sekaligus dalam file java.

Anda dapat mencoba menggunakan metode konvensional sederhana ini:

Ctrl+ Shift+R

menggantikan

Log.e(

Dengan

// Log.e(

Mudah dengan kotlin, cukup mendeklarasikan beberapa fungsi tingkat atas

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

cara paling sederhana;

menggunakan DebugLog

Semua log dinonaktifkan oleh DebugLog ketika aplikasi dirilis.

https://github.com/MustafaFerhan/DebugLog