Men-debug aplikasi Anda

Android Studio menyediakan debugger yang memungkinkan Anda melakukan hal-hal berikut ini dan banyak lagi:

  • Memilih perangkat untuk men-debug aplikasi Anda.
  • Menetapkan titik henti sementara dalam kode Java, Kotlin, dan C/C++.
  • Memeriksa variabel dan mengevaluasi ekspresi pada saat waktu proses.

Halaman ini berisi petunjuk untuk operasi debugger dasar. Untuk dokumentasi lainnya, lihat juga dokumen proses debug IDE IntelliJ.

Mengaktifkan proses debug

Sebelum mulai men-debug, Anda perlu mempersiapkan hal-hal berikut:

  • Instal LLDB:

    Jika project Anda berisi kode C/C++, Anda harus menginstal LLDB dari SDK Manager.

  • Aktifkan proses debug di perangkat Anda:

    Jika Anda menggunakan emulator, proses ini diaktifkan secara default. Namun, untuk perangkat yang terhubung, Anda perlu mengaktifkan proses debug dalam opsi developer perangkat.

  • Jalankan varian build yang dapat di-debug:

    Anda harus menggunakan varian build yang menyertakan debuggable true dalam konfigurasi build. Biasanya, Anda cukup memilih varian "debug" default yang disertakan dalam setiap project Android Studio (meskipun tidak terlihat dalam file build.gradle). Tetapi, jika Anda menentukan tipe build baru yang seharusnya dapat di-debug, Anda harus menambahkan `debuggable true` ke tipe build tersebut:

        android {
            buildTypes {
                customDebugType {
                    debuggable true
                    ...
                }
            }
        }
        

    Properti ini juga berlaku untuk modul dengan kode C/C++. (Properti jniDebuggable tidak digunakan lagi.)

Catatan: Jika aplikasi bergantung pada modul library yang ingin Anda debug juga, paketkan library tersebut dengan debuggable true agar mempertahankan simbol debugnya. Untuk memastikan bahwa varian project aplikasi yang dapat di-debug menerima varian modul library yang dapat di-debug, Anda harus memublikasikan library versi non-default milik Anda.

Memulai proses debug

Anda dapat memulai sesi proses debug dengan langkah berikut:

  1. Tetapkan beberapa titik henti sementara dalam kode aplikasi.
  2. Pada toolbar, pilih perangkat untuk men-debug aplikasi Anda dari menu drop-down perangkat target.

    Menu drop-down perangkat target.

    Jika tidak memiliki perangkat yang dikonfigurasi, Anda harus menghubungkan perangkat melalui USB atau membuat AVD untuk menggunakan Android Emulator.

  3. Di toolbar, klik Debug .

    Jika Anda melihat dialog yang menanyakan apakah Anda ingin "beralih dari Jalankan untuk Men-debug", artinya aplikasi Anda sudah berjalan di perangkat dan aplikasi akan dimulai ulang untuk memulai debugging. Jika Anda ingin instance aplikasi yang sama tetap berjalan, klik Cancel Debug dan sematkan debugger ke aplikasi yang sedang berjalan.

    Jika tidak, Android Studio membuat APK, menandatanganinya dengan kunci debug, menginstalnya di perangkat yang Anda pilih, dan menjalankannya. Jika Anda menambahkan kode C dan C++ ke project Anda, Android Studio juga akan menjalankan debugger LLDB di jendela Debug untuk men-debug kode native Anda.

  4. Jika jendela Debug tidak terbuka, pilih View > Tool Windows > Debug (atau klik Debug di jendela toolbar), lalu klik tab Debugger, seperti yang ditunjukkan pada gambar 1.

    Gambar 1. Jendela Debugger, menampilkan thread saat ini dan pohon objek untuk variabel

Menyematkan debugger ke aplikasi yang sedang berjalan

Jika aplikasi Anda sudah berjalan di perangkat, Anda dapat memulai proses debug tanpa memulai ulang aplikasi dengan cara berikut:

  1. Klik Attach debugger to Android process .
  2. Pada dialog Choose Process, pilih proses yang diinginakn untuk menyematkan debugger.

    Jika Anda menggunakan emulator atau perangkat yang telah di-root, Anda bisa mencentang Show all processes untuk melihat semua proses.

    Dari menu drop-down Debugger, Anda bisa memilih tipe debug lainnya. Secara default, Android Studio menggunakan tipe debug Auto untuk memilih opsi debugger terbaik berdasarkan apakah project Anda menyertakan kode Java atau C/C++.

  3. Klik OK.

    Jendela Debug akan muncul.

Catatan: Debugger dan pembersih sampah memori Android Studio terintegrasi dengan bebas. Mesin virtual Android menjamin bahwa setiap objek yang diketahui debugger tidak akan dibersihkan sampah memorinya hingga setelah sambungan debugger terputus. Hal ini dapat mengakibatkan penumpukan objek dari waktu ke waktu ketika debugger tersambung. Misalnya, jika debugger melihat thread yang berjalan, objek Thread yang terkait tidak akan dibersihkan sampah memorinya hingga sambungan debugger terputus, meskipun thread telah dihentikan.

Mengubah tipe debugger

Dibutuhkan beberapa fitur debugger untuk men-debug kode Java/Kotlin dan kode C/C++, oleh karena itu, debugger Android Studio memungkinkan Anda memilih tipe debugger yang akan digunakan. Secara default, Android Studio memutuskan debugger yang akan digunakan berdasarkan bahasa yang dideteksinya dalam project (dengan tipe debugger Auto). Namun, Anda dapat memilih debugger secara manual di konfigurasi debug (klik Run > Edit Configurations) atau pada dialog yang muncul ketika Anda mengklik Run > Attach debugger to Android process.

Tipe debug yang tersedia meliputi:

  • Auto: Pilih jika Anda ingin Android Studio memilih opsi terbaik secara otomatis untuk kode yang sedang di-debug. Misalnya, jika Anda memiliki kode C atau C++ dalam project, Android Studio akan menggunakan tipe debug Dual secara otomatis. Jika tidak, Android Studio akan menggunakan tipe debug Java.
  • Java: Pilih jika Anda hanya ingin men-debug kode yang ditulis dalam Java atau Kotlin. Debugger Java akan mengabaikan setiap titik henti sementara atau pengamatan yang ditetapkan dalam kode native Anda.
  • Native: (Hanya tersedia dengan kode C/C++.) Pilih jika Anda hanya ingin menggunakan LLDB untuk men-debug kode. Ketika menggunakan tipe debug ini, tampilan sesi debugger Java tidak akan tersedia. Secara default, LLDB hanya akan memeriksa kode native Anda dan mengabaikan titik henti sementara dalam kode Java. Jika ingin men-debug kode Java juga, Anda harus mengganti tipe debug ke Auto atau Dual.

    Catatan: Proses debug asli tidak berfungsi pada Windows 32-bit di Android Studio 3.0 dan yang lebih tinggi. Jika Anda menggunakan Windows 32-bit dan perlu men-debug kode native, gunakan Android Studio 2.3.

  • Dual: (Hanya tersedia dengan kode C/C++.) Pilih jika Anda ingin beralih antara men-debug kode Java dan kode native. Android Studio menyematkan debugger Java dan LLDB ke proses aplikasi Anda, satu untuk debugger Java dan satu untuk LLDB, sehingga Anda dapat memeriksa titik henti sementara dalam kode Java maupun kode native tanpa harus memulai ulang aplikasi Anda atau mengubah konfigurasi debug.

    Dalam gambar 2, perhatikan dua tab di sebelah kanan judul jendela Debug. Karena aplikasi memiliki kode Java dan C++, satu tab digunakan untuk men-debug kode native, dan lainnya untuk men-debug kode Java, sebagaimana ditunjukkan oleh -java.

    Gambar 2. Tab untuk men-debug kode native dan tab untuk men-debug kode Java

Catatan: Jika men-debug kode native yang dioptimalkan oleh kompilator, Anda mungkin mendapatkan pesan peringatan sebagai berikut: This function was compiled with optimizations enabled. .Some debugger features may not be available. Saat menggunakan tanda pengoptimalan, seperti tanda -O, kompilator akan membuat perubahan pada kode yang dihimpun agar berjalan lebih efisien. Hal ini dapat menyebabkan debugger melaporkan informasi yang tidak terduga atau informasi yang salah karena sulit bagi debugger untuk memetakan kembali kode yang telah dikompilasi dan dioptimalkan ke kode sumber aslinya. Untuk alasan ini, Anda harus menonaktifkan pengoptimalan kompilator saat men-debug kode native.

Menggunakan log sistem

Log sistem menampilkan pesan sistem ketika Anda men-debug aplikasi. Pesan ini berisi informasi dari aplikasi yang berjalan di perangkat. Jika Anda ingin menggunakan log sistem untuk men-debug aplikasi, pastikan kode Anda menulis pesan log dan mencetak pelacakan stack untuk pengecualian ketika aplikasi berada dalam tahap pengembangan.

Menulis pesan log dalam kode Anda

Untuk menulis pesan log dalam kode, gunakan class Log. Pesan log membantu Anda memahami alur eksekusi dengan mengumpulkan output debug sistem saat Anda berinteraksi dengan aplikasi. Pesan log dapat memberi tahu Anda tentang bagian aplikasi yang mengalami kegagalan. Untuk informasi selengkapnya terkait logging, lihat Menulis dan menampilkan log.

Contoh berikut menunjukkan bagaimana Anda dapat menambahkan pesan log untuk menentukan apakah informasi status sebelumnya tersedia ketika aktivitas dimulai:

Kotlin

    import android.util.Log
    ...
    private val TAG: String = MyActivity::class.java.simpleName
    ...
    class MyActivity : Activity() {
        ...
        override fun onCreate(savedInstanceState: Bundle?) {
            ...
            if (savedInstanceState != null) {
                Log.d(TAG, "onCreate() Restoring previous state")
                /* restore state */
            } else {
                Log.d(TAG, "onCreate() No saved state available")
                /* initialize app */
            }
        }
    }
    

Java

    import android.util.Log;
    ...
    public class MyActivity extends Activity {
        private static final String TAG = MyActivity.class.getSimpleName();
        ...
        @Override
        public void onCreate(Bundle savedInstanceState) {
           ...
           if (savedInstanceState != null) {
                Log.d(TAG, "onCreate() Restoring previous state");
                /* restore state */
            } else {
                Log.d(TAG, "onCreate() No saved state available");
                /* initialize app */
            }
        }
    }
    

Selama pengembangan, kode Anda juga dapat menangkap pengecualian dan menulis pelacakan stack ke log sistem:

Kotlin

    fun someOtherMethod() {
        try {
            ...
        } catch (e : SomeException) {
            Log.d(TAG, "someOtherMethod()", e)
        }
    }
    

Java

    void someOtherMethod() {
        try {
            ...
        } catch (SomeException e) {
            Log.d(TAG, "someOtherMethod()", e);
        }
    }
    

Catatan: Hapus pesan log debug dan panggilan cetak pelacakan stack dari kode ketika Anda sudah siap memublikasikan aplikasi. Anda dapat melakukannya dengan menetapkan tanda DEBUG dan menempatkan pesan log debug dalam pernyataan bersyarat.

Menampilkan log sistem

Anda dapat menampilkan dan memfilter pesan debug dan pesan sistem lainnya di jendela Logcat. Misalnya, Anda bisa melihat pesan saat pembersihan sampah memori dilaksanakan, atau pesan yang Anda tambahkan ke aplikasi dengan class Log.

Untuk menggunakan logcat, mulai proses debug, lalu pilih tab Logcat di toolbar bagian bawah seperti ditunjukkan dalam gambar 3.

Gambar 3. Jendela logcat dengan setelan filter

Untuk deskripsi tentang logcat dan opsi pemfilterannya, lihat Menulis dan menampilkan log dengan Logcat.

Bekerja dengan titik henti sementara

Android Studio mendukung beberapa tipe titik henti sementara yang memicu tindakan debug yang berbeda. Tipe yang paling umum adalah titik henti sementara baris yang menjeda eksekusi aplikasi pada baris kode yang ditetapkan. Saat dijeda, Anda dapat memeriksa variabel, mengevaluasi ekspresi, kemudian melanjutkan eksekusi baris demi baris untuk menentukan penyebab kesalahan waktu proses.

Untuk menambahkan titik henti sementara baris, lakukan langkah berikut:

  1. Temukan baris kode tempat eksekusi akan dijeda dan klik bagian tepi kiri di sepanjang baris kode tersebut, atau letakkan tanda sisipan pada baris dan tekan Control+F8 (di Mac, Command+F8).
  2. Jika aplikasi sudah berjalan, Anda tidak perlu mengupdatenya untuk menambahkan titik henti sementara. Cukup klik Attach debugger to Android proccess . Jika tidak, mulai debug dengan mengeklik Debug .

Gambar 3. Titik merah muncul di sebelah garis saat Anda menetapkan breakpoint

Saat eksekusi kode sudah mencapai titik henti sementara, Android Studio akan menghentikan sementara eksekusi aplikasi Anda. Kemudian Anda bisa menggunakan alat di tab Debugger untuk mengidentifikasi status aplikasi:

  • Untuk memeriksa pohon objek variabel, perluas pohon dalam tampilan Variables. Jika tampilan Variables tidak terlihat, klik Restore Variables View .

  • Untuk mengevaluasi ekspresi pada titik eksekusi saat ini, klik Evaluate Expression .

  • Untuk maju ke baris berikutnya dalam kode (tanpa memasukkan metode), klik Step Over .

  • Untuk maju ke baris pertama dalam panggilan metode, klik Step Into .

  • Untuk maju ke baris berikutnya di luar metode saat ini, klik Step Out .

  • Untuk terus menjalankan aplikasi secara normal, klik Resume Program .

Jika project Anda menggunakan kode asli, secara default tipe debug Auto akan menyematkan debugger Java dan LLDB ke aplikasi sebagai dua proses yang terpisah, sehingga Anda bisa beralih antara memeriksa titik henti sementara C/C++ dan Java tanpa memulai ulang aplikasi atau mengubah setelan.

Catatan: Agar Android Studio mendeteksi titik henti sementara dalam kode C atau C++, Anda harus menggunakan tipe debug yang mendukung LLDB, seperti Auto, Native, atau Dual. Anda dapat mengubah tipe debug yang digunakan Android Studio dengan mengedit konfigurasi debug Anda. Untuk mempelajari berbagai tipe debug selengkapnya, baca bagian tentang penggunaan tipe debug lainnya.

Ketika Android Studio menerapkan aplikasi Anda ke perangkat target, jendela Debug akan terbuka dengan tab atau tampilan sesi debug untuk setiap proses debugger, seperti ditunjukkan dalam gambar 4.

Gambar 4. Men-debug kode native menggunakan LLDB

  1. Android Studio akan beralih ke tab <your-module> ketika debugger LLDB menemukan titik henti sementara dalam kode C/C++. Panel Frames, Variables, dan Watches juga tersedia serta berfungsi sama persis seperti ketika Anda men-debug kode Java. Meskipun panel Threads tidak tersedia dalam tampilan sesi LLDB, Anda dapat mengakses proses aplikasi menggunakan menu drop-down di panel Frames. Pelajari panel ini lebih lanjut di bagian tentang cara men-debug frame jendela dan memeriksa variabel.

    Catatan: Ketika memeriksa titik henti sementara dalam kode native, sistem Android akan menangguhkan mesin virtual yang menjalankan bytecode Java milik aplikasi Anda. Artinya, Anda tidak dapat berinteraksi dengan debugger Java atau mengambil informasi status apa pun dari sesi debugger Java saat memeriksa titik henti sementara dalam kode native.

  2. Android Studio akan beralih ke tab <your-module>-java ketika debugger Java menemukan titik henti sementara dalam kode Java Anda.
  3. Saat men-debug dengan LLDB, Anda bisa menggunakan terminal LLDB dalam tampilan sesi LLDB untuk meneruskan opsi command line ke LLDB. Jika memiliki perintah tertentu yang ingin dieksekusi dengan LLDB setiap kali Anda mulai men-debug aplikasi, baik sebelum maupun setelah debugger disematkan ke proses aplikasi, Anda bisa menambahkan perintah tersebut ke konfigurasi debug.

Ketika men-debug kode C/C++, Anda juga dapat menyetel tipe titik henti sementara khusus, disebut watchpoint, yang dapat menangguhkan proses aplikasi ketika aplikasi berinteraksi dengan blok memori tertentu. Untuk mempelajari selengkapnya, baca bagian tentang cara menambahkan watchpoint.

Menampilkan dan mengonfigurasi titik henti sementara

Untuk menampilkan semua titik henti sementara dan mengonfigurasi setelan titik henti sementara, klik View Breakpoints di sisi kiri jendela Debug. Jendela Breakpoints akan muncul, seperti ditunjukkan dalam gambar 5.

Gambar 5. Jendela Breakpoints mencantumkan semua titik henti sementara saat ini dan menyertakan setelan perilaku untuk masing-masing.

Jendela Breakpoints memungkinkan Anda mengaktifkan atau menonaktifkan setiap titik henti sementara dari daftar di sebelah kiri. Jika titik henti sementara dinonaktifkan, Android Studio tidak akan menjeda aplikasi saat mencapai titik henti sementara tersebut. Pilih titik henti sementara dari daftar untuk mengonfigurasi setelannya. Anda dapat mengonfigurasi titik henti sementara agar dinonaktifkan terlebih dahulu dan meminta sistem untuk mengaktifkannya setelah titik henti sementara lainnya tercapai. Anda juga dapat mengonfigurasi apakah titik henti sementara harus dinonaktifkan setelah dicapai. Untuk mengatur titik henti sementara bagi suatu pengecualian, pilih Exception Breakpoints di daftar titik henti sementara.

Men-debug frame jendela

Di jendela Debugger, panel Frames memungkinkan Anda memeriksa frame tumpukan yang menyebabkan tercapainya titik henti sementara saat ini. Hal ini memungkinkan Anda membuka serta memeriksa frame stack, dan juga memeriksa daftar thread dalam aplikasi Android Anda. Untuk memilih thread, gunakan drop-down pemilih thread dan lihat frame stack-nya. Mengklik elemen dalam frame tersebut akan membuka sumber dalam editor. Anda juga dapat menyesuaikan penyajian thread dan mengekspor frame stack seperti yang dibahas dalam Panduan Frame Jendela.

Memeriksa variabel

Di jendela Debugger, panel Variables memungkinkan Anda memeriksa variabel ketika sistem menghentikan aplikasi pada titik akhir sementara dan Anda memilih frame dari panel Frames. Panel Variables juga memungkinkan Anda mengevaluasi ekspresi ad-hoc menggunakan metode statis dan/atau variabel yang tersedia dalam frame yang dipilih.

Panel Watches menyediakan fungsionalitas yang serupa, kecuali bahwa ekspresi yang ditambahkan ke panel Watches akan terus ada di antara sesi proses debug. Anda harus menambahkan pengamatan untuk variabel dan kolom yang sering diakses atau yang menyediakan keadaan yang berguna untuk sesi proses debug saat ini. Tampilan panel Variables dan Watches akan terlihat seperti ditunjukkan dalam gambar 5.

Untuk menambahkan variabel atau ekspresi ke daftar Watches, ikuti langkah-langkah berikut:

  1. Mulai proses debug.
  2. Di panel Watches, klik Add .
  3. Dalam kotak teks yang muncul, masukkan nama variabel atau ekspresi yang ingin Anda amati, lalu tekan Enter.

Untuk menghapus item dari daftar Watches, pilih item dan kemudian klik Remove .

Anda bisa mengubah urutan elemen dalam daftar Watches dengan memilih item lalu mengeklik Up atau Down .

Gambar 6. Panel Variables dan Watches di jendela Debugger

Menambahkan watchpoint

Ketika melakukan debug kode C/C++, Anda bisa mengatur tipe titik henti sementara khusus, disebut watchpoint, yang bisa menangguhkan proses aplikasi ketika aplikasi Anda berinteraksi dengan blok memori tertentu. Misalnya, jika Anda menyetel dua penunjuk ke sebuah blok memori dan menetapkan watchpoint ke blok memori tersebut, menggunakan salah satu penunjuk untuk mengakses blok memori tersebut akan memicu watchpoint yang telah ditetapkan.

Di Android Studio, Anda dapat membuat watchpoint pada waktu proses dengan memilih variabel tertentu, tetapi LLDB akan menetapkan watchpoint hanya pada blok memori yang dialokasikan oleh sistem ke variabel tersebut, bukan variabel itu sendiri. Hal ini berbeda dengan menambahkan variabel ke panel Watches, yang memungkinkan Anda mengamati nilai variabel tetapi tidak mengizinkan Anda menangguhkan proses aplikasi ketika sistem membaca atau mengubah nilainya dalam memori.

Catatan: Ketika proses aplikasi Anda keluar dari suatu fungsi dan sistem membatalkan alokasi variabel lokalnya dari memori, Anda harus menetapkan ulang setiap watchpoint yang telah dibuat untuk variabel tersebut.

Untuk menetapkan watchpoint, Anda harus memenuhi persyaratan berikut:

  • Emulator atau perangkat fisik target harus menggunakan CPU x86 atau x86_64. Jika perangkat menggunakan ARM CPU, Anda harus menyelaraskan batas alamat variabel dalam memori menjadi 4 byte untuk prosesor 32-bit, atau 8 byte untuk prosesor 64-bit. Anda bisa menyelaraskan variabel dalam kode asli dengan menetapkan __attribute__((aligned(num_bytes))) di deselerasi variabel, seperti yang ditunjukkan di bawah ini:
        // For a 64-bit ARM processor
        int my_counter __attribute__((aligned(8)));
        
  • Anda telah menetapkan tiga watchpoint atau lebih sedikit. Android Studio hanya mendukung hingga empat watchpoint pada perangkat target x86 atau x86_64. Perangkat lain mungkin mendukung lebih sedikit watchpoint.

Jika memenuhi persyaratan di atas, Anda dapat menambahkan watchpoint seperti berikut:

  1. Sementara aplikasi Anda ditangguhkan pada titik henti sementara, buka panel Variables dalam tampilan sesi LLDB.
  2. Klik kanan variabel yang menempati blok memori yang ingin Anda lacak, lalu pilih Add Watchpoint. Sebuah dialog untuk mengonfigurasi watchpoint akan muncul, seperti ditunjukkan dalam gambar 7.

    Gambar 7. Menambahkan watchpoint ke variabel dalam memori

  3. Konfigurasikan watchpoint dengan opsi berikut:
    • Enabled: Anda dapat membatalkan pilihan opsi ini jika ingin memberi tahu Android Studio agar mengabaikan watchpoint untuk saat ini. Android Studio tetap menyimpan watchpoint sehingga Anda dapat mengaksesnya kembali dalam sesi debug.
    • Suspend: Secara default, sistem Android akan menangguhkan proses aplikasi ketika aplikasi mengakses blok memori yang ditetapkan pada watchpoint. Anda dapat membatalkan pilihan opsi ini jika tidak menginginkan perilaku tersebut. Tindakan ini akan menampilkan opsi tambahan yang dapat Anda gunakan untuk menyesuaikan perilaku ketika sistem berinteraksi dengan watchpoint: Log message to console dan Remove [the watchpoint] when hit.
    • Access Type: Pilih apakah aplikasi Anda harus memicu watchpoint ketika mencoba Membaca atau Menulis ke blok memori yang dialokasikan oleh sistem pada variabel. Untuk memicu watchpoint pada mode baca atau tulis, pilih Any.
  4. Klik Done.

Untuk menampilkan semua watchpoint dan mengonfigurasi setelan watchpoint, klik View Breakpoints di sisi kiri jendela Debug. Dialog Breakpoints akan muncul, seperti ditunjukkan dalam gambar 8.

Gambar 8. Dialog Breakpoints mencantumkan watchpoint Anda saat ini dan menyertakan setelan perilaku untuk setiap watchpoint

Setelah Anda menambahkan watchpoint, klik Resume Program di sisi kiri jendela Debug untuk melanjutkan proses aplikasi. Secara default, jika aplikasi mencoba untuk mengakses blok memori yang telah diberi watchpoint, sistem Android akan menangguhkan proses aplikasi dan ikon watchpoint akan muncul di sebelah baris kode yang terakhir dijalankan oleh aplikasi, seperti ditunjukkan dalam gambar 9.

Gambar 9. Android Studio menunjukkan baris kode yang dijalankan aplikasi Anda sebelum memicu watchpoint

Menampilkan dan mengubah format tampilan nilai resource

Dalam mode debug, Anda dapat melihat nilai resource dan memilih format tampilan lain untuk variabel dalam kode Java. Setelah tab Variables ditampilkan dan frame dipilih, lakukan langkah-langkah berikut:

  1. Dalam daftar Variables, klik kanan di mana saja pada baris resource untuk menampilkan menu drop-down.
  2. Dalam menu drop-down, pilih View as, lalu pilih format yang ingin digunakan.

    Format yang tersedia bergantung pada tipe data resource yang Anda pilih. Anda mungkin melihat satu atau beberapa opsi berikut:

    • Class: Menampilkan definisi class.
    • toString: Menampilkan format string.
    • Object: Menampilkan definisi objek (instance suatu class).
    • Array: Menampilkan dalam format array.
    • Timestamp: Menampilkan tanggal dan waktu dalam format berikut: yyyy-mm-dd hh:mm:ss.
    • Auto: Android Studio akan memilih format terbaik berdasarkan tipe data.
    • Binary: Menampilkan nilai biner menggunakan angka nol dan satu.
    • MeasureSpec: Nilai yang diteruskan dari induk ke turunan yang dipilih. Lihat MeasureSpec.
    • Hex: Menampilkan sebagai nilai heksadesimal.
    • Primitive: Menampilkan sebagai nilai numerik menggunakan tipe data primitif.
    • Integer: Menampilkan nilai numerik bertipe Integer.

Anda dapat membuat format khusus (perender tipe data) dengan langkah berikut:

  1. Klik kanan nilai resource.
  2. Pilih View as.
  3. Pilih Create. Dialog Java Data Type Renderers akan muncul.
  4. Ikuti petunjuk dalam Perender Tipe data Java.