Tampilan Cepat
- Android dijalankan pada berbagai perangkat yang memiliki kepadatan dan ukuran layar berbeda.
- Layar untuk menampilkan aplikasi Anda bisa memengaruhi antarmuka penggunanya.
- Sistem menangani hampir semua pekerjaan mengadaptasikan aplikasi Anda ke layar saat ini.
- Anda harus membuat sumber daya layar spesifik untuk mendapatkan kontrol akurat atas UI.
Dalam dokumen ini
- Ringkasan Dukungan Layar
- Cara Mendukung Multilayar
- Mendeklarasikan Layout Tablet untuk Android 3.2
- Praktik Terbaik
- Pertimbangan Tambahan mengenai Kepadatan
- Cara Menguji Aplikasi Anda di Multilayar
Contoh-contoh terkait
Lihat juga
Android dijalankan pada beragam perangkat yang menawarkan kepadatan dan ukuran layar yang berbeda. Untuk aplikasi, sistem Android menyediakan lingkungan development yang konsisten di berbagai perangkat dan menangani hampir semua pekerjaan untuk menyesuaikan antarmuka pengguna aplikasi ke layar yang menampilkannya. Pada saat yang sama, sistem menyediakan beberapa API yang memungkinkan Anda mengontrol UI aplikasi untuk kepadatan dan ukuran layar tertentu, untuk mengoptimalkan desain UI Anda bagi konfigurasi layar yang berbeda. Misalnya, Anda mungkin ingin UI untuk tablet berbeda dari UI untuk handset.
Walaupun sistem menskalakan dan mengubah ukuran untuk membuat aplikasi bisa berfungsi pada layar berbeda, Anda harus berusaha mengoptimalkan aplikasi untuk kepadatan dan ukuran layar yang berbeda. Dalam melakukannya, maksimalkan pengalaman pengguna untuk semua perangkat dan pengalaman pengguna Anda meyakini bahwa aplikasi Anda benar-benar didesain untuk perangkat mereka—bukan sekadar direntang agar pas dengan layar perangkat mereka.
Dengan mengikuti praktik yang dijelaskan dalam dokumen ini, Anda bisa membuat aplikasi yang menampilkan
dengan benar dan menyediakan pengalaman pengguna yang dioptimalkan pada semua konfigurasi layar yang didukung,
dengan menggunakan satu file .apk
.
Catatan: Informasi dalam dokumen ini beranggapan bahwa aplikasi Anda
didesain untuk Android 1.6 (API Level 4) atau yang lebih tinggi. Jika aplikasi Anda mendukung
Android 1.5 atau yang lebih rendah, bacalah terlebih dahulu Strategi untuk Android 1.5.
Selain itu, ketahuilah bahwa Android 3.2 telah memperkenalkan beberapa API baru yang memungkinkan Anda lebih
akurat mengontrol sumber daya layout yang digunakan aplikasi untuk beragam ukuran layar. Semua fitur baru
ini sangat penting jika Anda sedang mengembangkan aplikasi yang dioptimalkan untuk tablet.
Untuk detailnya, lihat bagian tentang Mendeklarasikan Layout Tablet untuk
Android 3.2.
Ringkasan Dukungan Layar
Bagian ini menyediakan ringkasan mengenai dukungan Android untuk multilayar, termasuk: pengantar untuk istilah dan konsep yang digunakan dalam dokumen ini serta dalam API, rangkuman konfigurasi layar yang didukung sistem, dan ringkasan mengenai API serta fitur kompatibilitas layar yang mendasarinya.
Istilah dan konsep
- Ukuran layar
- Ukuran fisik sesungguhnya, yang diukur sebagai diagonal layar.
Untuk penyederhanaan, Android mengelompokkan semua ukuran layar sesungguhnya ke dalam empat ukuran umum: kecil, normal, besar, dan ekstra besar.
- Kepadatan layar
- Jumlah piksel dalam area fisik layar; biasa disebut sebagai dpi (dot
per inci). Misalnya, layar berkepadatan "rendah" memiliki piksel lebih sedikit dalam area fisik yang diberikan,
dibandingkan layar berkepadatan "normal" atau "tinggi".
Untuk penyederhanaan, Android mengelompokkan semua kepadatan layar sesungguhnya ke dalam enam kepadatan umum: rendah, medium, tinggi, ekstra-tinggi, ekstra-ekstra-tinggi, dan ekstra-ekstra-ekstra-tinggi.
- Orientasi
- Orientasi layar dari sudut pandang pengguna. Orientasi ini bisa berupa lanskap atau potret, berarti masing-masing rasio aspek layar bisa berupa melebar atau meninggi. Ketahuilah bahwa secara default tidak hanya melakukan pengoperasian perangkat berbeda dalam orientasi berbeda, melainkan orientasi bisa berubah pada waktu proses bila pengguna memutar perangkat.
- Resolusi
- Total jumlah piksel fisik di layar. Saat menambahkan dukungan untuk multilayar, aplikasi tidak menangani resolusi secara langsung; aplikasi hanya perlu memperhatikan ukuran dan kepadatan layar, sebagaimana ditetapkan oleh kelompok kepadatan dan ukuran umum.
- Piksel berkepadatan independen (dp)
- Satuan piksel virtual yang harus Anda gunakan saat mendefinisikan layout UI, untuk menyatakan dimensi layout
atau posisi dengan cara yang tidak bergantung pada kepadatan.
Piksel berkepadatan independen sama dengan satu piksel fisik pada layar 160 dpi, yang merupakan kepadatan patokan yang diasumsikan oleh sistem untuk layar kepadatan "medium". Pada waktu proses, sistem secara transparan menangani penskalaan satuan dp, bila diperlukan, berdasarkan kepadatan sesungguhnya dari layar yang digunakan. Konversi satuan dp ke piksel layar adalah sederhana:
. Misalnya, pada layar 240 dpi, 1 dp sama dengan 1,5 piksel fisik. Anda harus selalu menggunakan satuan dp saat mendefinisikan UI aplikasi Anda untuk memastikan UI Anda ditampilkan dengan benar di layar yang memiliki kepadatan berbeda.px = dp * (dpi / 160)
Ragam layar yang didukung
Mulai Android 1.6 (API Level 4), Android menyediakan dukungan untuk kepadatan dan ukuran layar yang beragam, yang mencerminkan banyak konfigurasi layar berbeda yang mungkin dimiliki perangkat. Anda bisa menggunakan fitur sistem Android untuk mengoptimalkan antarmuka pengguna aplikasi untuk setiap konfigurasi layar dan memastikan aplikasi Anda tidak hanya dirender, juga menyediakan pengalaman pengguna yang sebaik mungkin di setiap layar.
Untuk menyederhanakan cara mendesain antarmuka pengguna Anda bagi multilayar, Android membagi rentang kepadatan dan ukuran layar sesungguhnya ke dalam:
- Ada empat ukuran umum: kecil, normal,
besar,
dan ekstra besar
Catatan: Mulai Android 3.2 (API level 13), kelompok ukuran ini tidak digunakan lagi karena sudah ada teknik baru untuk mengelola ukuran layar berdasarkan lebar layar yang tersedia. Jika Anda sedang mengembangkan untuk Android 3.2 dan yang lebih baru, lihat Mendeklarasikan Layout Tablet untuk Android 3.2 untuk informasi selengkapnya.
- Ada enam kepadatan umum:
- ldpi (rendah) ~120 dpi
- mdpi (medium) ~160 dpi
- hdpi (tinggi) ~240 dpi
- xhdpi (ekstra-tinggi) ~320 dpi
- xxhdpi (ekstra-ekstra-tinggi) ~480 dpi
- xxxhdpi (ekstra-ekstra-ekstra-tinggi) ~640 dpi
Ukuran dan kepadatan umum membentuk suatu konfigurasi patokan yakni ukuran normal dan kepadatan mdpi (medium). Patokan ini berdasarkan pada konfigurasi layar untuk perangkat Android yang pertama, yakni T-Mobile G1, yang memiliki layar HVGA (hingga Android 1.6, inilah satu-satunya konfigurasi layar yang didukung oleh Android).
Setiap kepadatan dan ukuran umum meliputi serangkaian kepadatan dan ukuran layar sesungguhnya. Misalnya, dua perangkat yang melaporkan ukuran layar normal mungkin memiliki ukuran layar sesungguhnya dan rasio aspek yang sedikit berbeda bila diukur secara manual. Begitu pula, dua perangkat yang melaporkan kepadatan layar hdpi mungkin memiliki kepadatan piksel sebenarnya yang sedikit berbeda. Android membuat abstrak perbedaan ini pada berbagai aplikasi, jadi Anda bisa menyediakan UI yang didesain untuk kepadatan dan ukuran umum dan memungkinkan sistem menangani penyesuaian akhir bila diperlukan. Gambar 1 mengilustrasikan bagaimana ukuran dan kepadatan yang berbeda dikelompokkan secara kasar ke dalam beberapa kelompok kepadatan dan ukuran yang berbeda pula.

Gambar 1. Ilustrasi mengenai bagaimana Android secara kasar memetakan ukuran dan kepadatan sesungguhnya ke beberapa ukuran dan kepadatan umum (angkanya tidak persis sama).
Karena Anda mendesain UI untuk ukuran layar berbeda, Anda akan mengetahui bahwa setiap desain memerlukan jumlah ruang minimum. Jadi, setiap ukuran layar umum di atas memiliki resolusi minimum yang didefinisikan oleh sistem. Ukuran minimum ini dalam satuan "dp"—satuan yang sama yang harus Anda gunakan saat mendefinisikan layout—yang memungkinkan sistem menghindari kekhawatiran tentang perubahan kepadatan layar.
- ekstra besar ukuran layar minimal 960 dp x 720 dp
- besar ukuran layar minimal 640 dp x 480 dp
- normal ukuran layar minimal 470 dp x 320 dp
- kecil ukuran layar minimal 426 dp x 320 dp
Catatan: Ukuran layar minimum ini semula tidak didefinisikan dengan baik sebelum Android 3.0, jadi Anda mungkin menemukan sebagian perangkat yang salah diklasifikasikan antara normal dan besar. Hal ini juga berdasarkan pada resolusi fisik layar, jadi mungkin akan bervariasi di semua perangkat—misalnya tablet 1024x720 dengan bilah sistem sebenarnya memiliki ruang lebih kecil untuk aplikasi saat digunakan oleh bilah sistem.
Untuk mengoptimalkan UI aplikasi Anda bagi beberapa kepadatan dan ukuran layar yang berbeda, Anda bisa menyediakan sumber daya alternatif untuk kepadatan dan ukuran layar umum. Biasanya, Anda harus menyediakan layout alternatif untuk beberapa ukuran layar yang berbeda dan gambar bitmap alternatif untuk kepadatan layar berbeda. Pada waktu proses, sistem menggunakan sumber daya yang sesuai untuk aplikasi Anda, berdasarkan pada ukuran atau kepadatan umum layar perangkat saat ini.
Anda tidak perlu menyediakan sumber daya alternatif bagi setiap kombinasi kepadatan dan ukuran layar. Sistem menyediakan fitur kompatibilitas tangguh yang bisa menangani hampir semua pekerjaan rendering aplikasi Anda pada layar perangkat apa saja, asalkan Anda mengimplementasikan UI dengan menggunakan teknik-teknik yang memungkinkannya mengubah ukuran secara mulus (seperti yang dijelaskan dalam Praktik Terbaik, di bawah).
Catatan: Karakteristik yang mendefinisikan kepadatan dan ukuran layar umum perangkat tidak bergantung pada satu sama lain. Misalnya, layar berkepadatan tinggi WVGA dianggap ukuran layar normal karena ukuran fisiknya kurang-lebih sama dengan T-Mobile G1 (perangkat Android pertama dan konfigurasi layar patokan). Dengan kata lain, layar berkepadatan medium WVGA dianggap layar berukuran besar. Walaupun menawarkan resolusi yang sama (jumlah piksel yang sama), layar berkepadatan medium WVGA memiliki kepadatan layar yang lebih rendah, artinya setiap piksel secara fisik lebih besar dan, karena itu, keseluruhan layar menjadi lebih besar dari layar patokan (ukuran normal).
Independensi kepadatan
Aplikasi Anda akan mencapai "independensi kepadatan" bila mempertahankan ukuran fisik (dari sudut pandang pengguna) elemen antarmuka pengguna bila ditampilkan pada layar yang memiliki kepadatan berbeda.
Independensi kepadatan penting untuk dipertahankan karena tanpa itu, elemen UI (misalnya tombol) akan muncul lebih besar secara fisik pada layar berkepadatan rendah dan lebih kecil pada layar berkepadatan tinggi. Perubahan ukuran terkait-kepadatan tersebut bisa menyebabkan masalah di layout aplikasi Anda dan kegunaannya. Gambar 2 dan 3 menunjukkan perbedaan antara bila aplikasi tidak menyediakan independensi kepadatan dan bila menyediakannya.

Gambar 2. Aplikasi contoh tanpa dukungan untuk kepadatan berbeda, seperti yang ditunjukkan pada layar berkepadatan tinggi, medium, dan rendah.

Gambar 3. Aplikasi contoh dengan dukungan yang baik untuk berbagai kepadatan (berkepadatan independen), seperti yang ditunjukkan pada layar berkepadatan tinggi, medium, dan rendah.
Sistem Android membantu aplikasi Anda mencapai independensi kepadatan dengan dua cara:
- Sistem menskalakan satuan dp sebagaimana mestinya untuk kepadatan layar saat ini
- Sistem menskalakan sumber daya dapat digambar ke ukuran yang sesuai, berdasarkan kepadatan layar saat ini, jika perlu
Dalam gambar 2, tampilan teks dan sumber daya dapat digambar yang berupa bitmap memiliki dimensi yang ditetapkan dalam piksel (satuan px
),
sehingga tampilan tersebut secara fisik lebih besar pada layar berkepadatan rendah
dan lebih kecil pada layar berkepadatan tinggi. Hal ini karena walaupun ukuran layar sesungguhnya mungkin sama, layar berkepadatan tinggi
memiliki piksel per inci yang lebih banyak (jumlah piksel yang sama muat dalam bidang yang lebih kecil). Dalam gambar 3, dimensi
layout ditetapkan dalam piksel berkepadatan independen (satuan dp
). Karena patokan untuk
piksel berkepadatan independen adalah layar berkepadatan medium, perangkat yang memiliki layar berkepadatan medium akan terlihat
sama dengan yang ada di gambar 2. Akan tetapi untuk layar berkepadatan tinggi dan rendah, sistem akan
menaikkan atau menurunkan nilai piksel berkepadatan independen agar pas dengan layar
sebagaimana mestinya.
Pada umumnya, Anda bisa memastikan independensi kepadatan di aplikasi cukup dengan menetapkan semua
nilai dimensi layout dalam piksel berkepadatan independen (satuan dp
) atau dengan "wrap_content"
dengan semestinya. Kemudian sistem akan menskalakan sumber daya dapat digambar berupa bitmap agar dapat
menampilkan pada ukuran yang sesuai, berdasarkan pada faktor penskalaan yang sesuai untuk
kepadatan layar saat ini.
Akan tetapi, penskalaan bitmap bisa mengakibatkan bitmap yang kabur atau pikselasi, yang bisa Anda amati dalam tangkapan layar di atas. Untuk menghindari artefak ini, Anda harus menyediakan sumber daya bitmap alternatif untuk kepadatan berbeda. Misalnya, Anda harus menyediakan bitmap yang beresolusi lebih tinggi untuk layar berkepadatan tinggi dan sistem akan menggunakannya sebagai ganti mengubah ukuran bitmap yang didesain untuk layar berkepadatan medium. Bagian berikut menjelaskan selengkapnya tentang cara menyediakan sumber daya alternatif untuk konfigurasi layar berbeda.
Cara Mendukung Multilayar
Fondasi dukungan Android untuk multilayar adalah kemampuannya mengelola rendering layout aplikasi dan sumber daya dapat digambar berupa bitmap dengan cara semestinya untuk konfigurasi layar saat ini. Sistem menangani hampir semua pekerjaan untuk merender aplikasi Anda dengan benar pada setiap konfigurasi layar dengan menskalakan layout agar pas dengan kepadatan/ukuran layar dan menskalakan sumber daya dapat digambar yang berupa bitmap untuk kepadatan layar, sebagaimana mestinya. Akan tetapi, agar lebih mulus dalam menangani konfigurasi layar berbeda, Anda juga harus:
- Secara eksplisit mendeklarasikan dalam manifes ukuran layar mana yang didukung
aplikasi Anda
Dengan mendeklarasikan ukuran layar yang didukung aplikasi, Anda bisa memastikan bahwa hanya perangkat dengan layar yang didukung saja yang bisa mengunduh aplikasi Anda. Mendeklarasikan dukungan untuk ukuran layar berbeda juga bisa memengaruhi cara sistem menggambar aplikasi Anda pada layar yang lebih besar—khususnya, bila aplikasi berjalan dalam mode kompatibilitas layar.
Untuk mendeklarasikan ukuran layar yang didukung aplikasi, Anda harus menyertakan elemen
<supports-screens>
dalam file manifes. - Menyediakan layout berbeda untuk ukuran layar berbeda
Secara default, Android mengubah ukuran layout aplikasi Anda agar pas dengan layar perangkat saat ini. Umumnya, ini akan berhasil. Dalam kasus lain, UI Anda mungkin terlihat tidak bagus dan perlu penyesuaian untuk ukuran layar yang berbeda. Misalnya, pada layar yang lebih besar, Anda mungkin ingin menyesuaikan posisi dan ukuran sebagian elemen untuk memanfaatkan ruang layar tambahan, atau pada layar yang lebih kecil, Anda mungkin perlu menyesuaikan ukuran agar semuanya bisa pas pada layar.
Qualifier konfigurasi yang bisa Anda gunakan untuk menyediakan sumber daya ukuran spesifik adalah
small
,normal
,large
, danxlarge
. Misalnya, layout untuk layar ekstra besar harus masuk dalamlayout-xlarge/
.Mulai Android 3.2 (API level 13), kelompok ukuran di atas tidak digunakan lagi dan sebagai gantinya Anda harus menggunakan qualifier konfigurasi
sw<N>dp
untuk mendefinisikan lebar yang tersedia terkecil yang diperlukan oleh sumber daya layout. Misalnya, jika layout tablet multipanel memerlukan lebar layar setidaknya 600 dp, maka Anda harus memasukkannya dalamlayout-sw600dp/
. Penggunaan teknik-teknik baru untuk mendeklarasikan sumber daya layout akan dibahas lebih jauh di bagian tentang Mendeklarasikan Layout Tablet untuk Android 3.2. - Menyediakan sumber daya dapat digambar berupa bitmap untuk kepadatan layar berbeda
Secara default, Android menskalakan sumber daya dapat digambar berupa bitmap (file
.png
,.jpg
, dan.gif
) dan sumber daya dapat digambar berupa Nine-Patch (file.9.png
) akan dirender pada ukuran fisik yang sesuai di setiap perangkat. Misalnya, jika aplikasi Anda menyediakan sumber daya dapat digambar berupa bitmap hanya untuk patokan, kepadatan layar medium (mdpi), kemudian sistem akan menaikkan skalanya bila di layar berkepadatan tinggi, dan menurunkan skalanya bila di layar berkepadatan rendah. Penskalaan ini bisa menyebabkan artefak di bitmap. Untuk memastikan penampilan terbaik bitmap, Anda harus menyertakan versi alternatif pada resolusi berbeda untuk kepadatan layar berbeda.Qualifier konfigurasi (dijelaskan secara detail di bawah ini) yang bisa Anda gunakan untuk sumber daya kepadatan spesifik
ldpi
(rendah),mdpi
(medium),hdpi
(tinggi),xhdpi
ekstra-tinggi),xxhdpi
(ekstra-ekstra-tinggi), danxxxhdpi
(ekstra-ekstra-ekstra-tinggi). Misalnya, bitmap untuk layar berkepadatan tinggi harus dimasukkan dalamdrawable-hdpi/
.Catatan: Qualifier
mipmap-xxxhdpi
hanya diperlukan untuk menyediakan ikon peluncur yang bisa tampak lebih besar dari biasanya pada perangkat xxhdpi. Anda tidak perlu menyediakan aset xxxhdpi untuk semua gambar aplikasi.Sebagian perangkat menaikkan skala ikon peluncur sebesar 25%. Misalnya, jika gambar ikon peluncur berkepadatan tertinggi Anda sudah berkepadatan ekstra-ekstra-tinggi, proses penskalaan akan membuatnya tampak kurang tajam. Jadi Anda harus menyediakan ikon peluncur berkepadatan lebih tinggi dalam direktori
mipmap-xxxhdpi
, yang digunakan sistem sebagai ganti menaikkan skala ikon versi lebih kecil.Lihat Menyediakan ikon peluncur berkepadatan ekstra-ekstra-ekstra-tinggi untuk informasi selengkapnya. Anda tidak boleh menggunakan qualifier
xxxhdpi
untuk elemen UI selain ikon peluncur.
Catatan: Masukkan semua ikon peluncur Anda dalam folder
res/mipmap-[density]/
, bukan dalam folder res/drawable-[density]/
.
Sistem Android menyimpan sumber daya dalam folder kepadatan spesifik, misalnya
mipmap-xxxhdpi, berapa pun resolusi layar perangkat tempat memasang aplikasi Anda. Perilaku ini
memungkinkan aplikasi peluncur memilih ikon beresolusi terbaik untuk aplikasi Anda guna ditampilkan pada
layar beranda. Untuk informasi selengkapnya tentang menggunakan folder mipmap, lihat
Mengelola Ringkasan Proyek.
Qualifier konfigurasi ukuran dan kepadatan berkaitan dengan ukuran dan kepadatan umum yang dijelaskan dalam Ragam layar yang didukung, di atas.
Catatan: Jika Anda tidak familier dengan qualifier konfigurasi dan cara sistem menggunakannya untuk menerapkan sumber daya alternatif, baca Menyediakan Sumber Daya Alternatif untuk informasi selengkapnya.
Pada waktu proses, sistem akan memastikan tampilan yang sebaik mungkin pada layar saat ini dengan prosedur berikut bagi sumber daya yang diberikan:
- Sistem akan menggunakan sumber daya alternatif yang sesuai
Berdasarkan ukuran dan kepadatan layar saat ini, sistem menggunakan sumber daya ukuran-dan kepadatan-spesifik apa saja yang disediakan dalam aplikasi Anda. Misalnya, jika perangkat memiliki layar berkepadatan tinggi dan aplikasi meminta sumber daya dapat digambar, sistem akan mencari direktori sumber daya dapat digambar yang paling cocok dengan konfigurasi perangkat. Bergantung pada sumber daya alternatif yang tersedia lainnya, direktori sumber daya dengan qualifier
hdpi
(misalnyadrawable-hdpi/
) mungkin menjadi yang paling cocok, jadi sistem menggunakan sumber daya dapat digambar dari direktori ini. - Jika tidak ada sumber daya yang cocok, sistem akan menggunakan sumber daya default dan menaikkan
atau menurunkan skalanya bila diperlukan agar cocok dengan kepadatan dan ukuran layar saat ini
Sumber daya "default" adalah sumber daya yang tidak diberi tag dengan qualifier konfigurasi. Misalnya, sumber daya dalam
drawable/
adalah sumber daya dapat digambar default. Sistem beranggapan sumber daya default didesain untuk kepadatan dan ukuran layar patokan, yakni ukuran layar normal dan kepadatan medium. Dengan demikian, sistem akan menaikkan skala sumber daya kepadatan default untuk layar berkepadatan tinggi dan menurunkannya untuk layar berkepadatan rendah, sebagaimana mestinya.Akan tetapi, bila sistem mencari sumber daya kepadatan spesifik dan tidak menemukannya dalam direktori kepadatan spesifik, sistem tidak akan selalu menggunakan sumber daya default. Sebagai gantinya sistem mungkin menggunakan salah satu sumber daya kepadatan spesifik lainnya agar dapat menyediakan hasil yang lebih baik saat menskalakan. Misalnya, saat mencari sumber daya kepadatan rendah namun tidak tersedia, sistem akan lebih suka menurunkan skala sumber daya versi kepadatan tinggi, karena sistem bisa dengan mudah menurunkan skala sumber daya kepadatan tinggi menjadi sumber daya kepadatan rendah melalui faktor 0,5, dengan artefak lebih sedikit, dibandingkan menskalakan sumber daya kepadatan medium melalui faktor 0,75.
Untuk informasi selengkapnya tentang cara Android memilih sumber daya alternatif dengan mencocokkan qualifier konfigurasi pada konfigurasi perangkat, baca Cara Android Menemukan Sumber Daya yang Paling Cocok.
Menggunakan qualifier konfigurasi
Android mendukung beberapa qualifier konfigurasi yang memungkinkan Anda mengontrol cara sistem memilih sumber daya alternatif berdasarkan karakteristik layar perangkat saat ini. Qualifier konfigurasi adalah sebuah string yang bisa Anda tambahkan ke direktori sumber daya dalam proyek Android dan menetapkan konfigurasi bagi desain sumber daya yang ada di dalamnya.
Untuk menggunakan qualifier konfigurasi:
- Buat direktori baru dalam direktori
res/
proyek Anda dan beri nama dengan format:<resources_name>-<qualifier>
<resources_name>
adalah nama sumber daya standar (misalnyadrawable
ataulayout
).<qualifier>
adalah qualifier konfigurasi dari tabel 1, di bawah, yang menetapkan konfigurasi layar yang akan digunakan bersama sumber daya ini (misalnyahdpi
atauxlarge
).
Anda bisa menggunakan lebih dari satu
<qualifier>
untuk setiap kalinya—cukup dengan memisahkan setiap qualifier dengan tanda hubung. - Simpan sumber daya konfigurasi spesifik yang sesuai dalam direktori baru ini. File sumber daya harus dinamai sama persis dengan file sumber daya default.
Misalnya, xlarge
adalah qualifier konfigurasi untuk layar ekstra-besar. Bila Anda menambahkan
string ini ke nama direktori sumber daya (misalnya layout-xlarge
), ini menunjukkan pada
sistem bahwa sumber daya ini akan digunakan pada perangkat yang memiliki layar ekstra-besar.
Tabel 1. Qualifier konfigurasi yang memungkinkan Anda menyediakan sumber daya khusus untuk konfigurasi layar berbeda.
Karakteristik layar | Qualifier | Keterangan |
---|---|---|
Ukuran | small |
Sumber daya untuk layar berukuran kecil. |
normal |
Sumber daya untuk layar berukuran normal. (Ini adalah ukuran patokan.) | |
large |
Sumber daya untuk layar berukuran besar. | |
xlarge |
Sumber daya untuk layar berukuran ekstra-besar. | |
Kepadatan | ldpi |
Sumber daya untuk layar berkepadatan rendah (ldpi) (~120 dpi). |
mdpi |
Sumber daya untuk layar berkepadatan medium (mdpi) (~160 dpi). (Ini adalah kepadatan patokan.) | |
hdpi |
Sumber daya untuk layar berkepadatan tinggi (hdpi) (~240 dpi). | |
xhdpi |
Sumber daya untuk layar berkepadatan ekstra-tinggi (xhdpi) (~320 dpi). | xxhdpi |
Sumber daya untuk layar berkepadatan ekstra-ekstra-tinggi (xxhdpi) (~480 dpi). | xxxhdpi |
Sumber daya untuk layar berkepadatan ekstra-ekstra-tinggi-tinggi (xxxhdpi) (~640 dpi). Gunakan ini hanya untuk ikon peluncur, lihat catatan di atas. |
nodpi |
Sumber daya untuk semua kepadatan. Ini adalah sumber daya kepadatan independen. Sistem tidak menskalakan sumber daya yang diberi tag dengan qualifier ini, berapa pun kepadatan layar saat ini. | |
tvdpi |
Sumber daya untuk layar antara mdpi dan hdpi; sekitar 213 dpi. Ini tidak dianggap sebagai kelompok kepadatan "utama". Sebagian besar ditujukan untuk televisi dan kebanyakan aplikasi tidak memerlukannya—menyediakan sumber daya mdpi dan hdpi sudah cukup untuk sebagian besar aplikasi dan sistem akan menskalakan sebagaimana mestinya. Jika merasa perlu menyediakan sumber daya tvdpi, Anda harus menyetel ukurannya pada faktor 1,33*mdpi. Misalnya, gambar 100 px x 100 px untuk layar mdpi akan menjadi 133 px x 133 px untuk tvdpi. | |
Orientasi | land |
Sumber daya untuk layar dalam orientasi lanskap (rasio aspek lebar). |
port |
Sumber daya untuk layar dalam orientasi potret (rasio aspek tinggi). | |
Rasio aspek | long |
Sumber daya untuk layar yang memiliki rasio aspek yang secara signifikan lebih tinggi atau lebih lebar (masing-masing bila dalam orientasi lanskap atau potret) daripada konfigurasi layar patokan. |
notlong |
Sumber daya untuk layar yang memiliki rasio aspek mirip dengan konfigurasi layar patokan. |
Catatan: Jika Anda sedang mengembangkan aplikasi untuk Android 3.2 dan yang lebih tinggi, lihat bagian tentang Mendeklarasikan Layout Tablet untuk Android 3.2 untuk informasi tentang qualifier konfigurasi baru yang harus Anda gunakan saat mendeklarasikan sumber daya layout untuk ukuran layar spesifik (sebagai ganti menggunakan qualifier ukuran dalam tabel 1).
Untuk informasi selengkapnya tentang bagaimana qualifier ini secara kasar terkait dengan kepadatan dan ukuran layar sesungguhnya, lihat Ragam Layar yang Didukung, di bagian sebelumnya dalam dokumen ini.
Misalnya, direktori sumber daya aplikasi berikut menyediakan beragam desain layout
untuk ukuran layar berbeda dan sumber daya dapat digambar berbeda. Gunakan folder mipmap/
untuk
ikon peluncur.
res/layout/my_layout.xml // layout for normal screen size ("default") res/layout-large/my_layout.xml // layout for large screen size res/layout-xlarge/my_layout.xml // layout for extra-large screen size res/layout-xlarge-land/my_layout.xml // layout for extra-large in landscape orientation res/drawable-mdpi/graphic.png // bitmap for medium-density res/drawable-hdpi/graphic.png // bitmap for high-density res/drawable-xhdpi/graphic.png // bitmap for extra-high-density res/drawable-xxhdpi/graphic.png // bitmap for extra-extra-high-density res/mipmap-mdpi/my_icon.png // launcher icon for medium-density res/mipmap-hdpi/my_icon.png // launcher icon for high-density res/mipmap-xhdpi/my_icon.png // launcher icon for extra-high-density res/mipmap-xxhdpi/my_icon.png // launcher icon for extra-extra-high-density res/mipmap-xxxhdpi/my_icon.png // launcher icon for extra-extra-extra-high-density
Untuk informasi selengkapnya tentang cara menggunakan sumber daya alternatif dan daftar lengkap qualifier konfigurasi (tidak cuma untuk konfigurasi layar), lihat Menyediakan Sumber Daya Alternatif.
Ketahuilah bahwa, bila sistem Android memilih sumber daya yang akan digunakan pada waktu proses, sistem akan menggunakan
logika tertentu untuk menentukan sumber daya yang "paling cocok". Yakni, qualifier yang Anda gunakan tidak harus
persis sama dengan konfigurasi layar saat ini di semua kasus agar sistem
bisa menggunakannya. Khususnya, saat memilih sumber daya berdasarkan qualifier ukuran, sistem akan menggunakan
sumber daya yang didesain untuk layar yang lebih kecil daripada layar saat ini jika tidak ada
sumber daya yang lebih cocok (misalnya, layar ukuran besar akan menggunakan sumber daya
layar ukuran normal jika diperlukan). Akan tetapi, jika satu-satunya sumber daya yang tersedia lebih besar daripada layar saat ini, sistem
tidak akan menggunakannya dan aplikasi Anda akan mogok jika tidak ada sumber daya lain yang cocok dengan konfigurasi
perangkat (misalnya, jika semua sumber daya layout diberi tag qualifier xlarge
,
namun perangkat memiliki layar berukuran normal). Untuk informasi selengkapnya tentang cara sistem memilih
sumber daya, baca Cara Android Menemukan
Sumber Daya yang Paling Cocok.
Tip: Jika Anda memiliki beberapa sumber daya dapat digambar yang tidak boleh
diskalakan oleh sistem (mungkin karena Anda melakukan beberapa penyesuaian
sendiri pada gambar pada waktu proses), Anda harus memasukkannya dalam direktori dengan qualifier konfigurasi nodpi
.
Sumber daya dengan qualifier ini dianggap tidak bergantung pada kepadatan tertentu
dan sistem tidak akan menskalakannya.
Mendesain layout alternatif dan sumber daya dapat digambar
Tipe sumber daya alternatif yang harus Anda buat bergantung pada kebutuhan aplikasi. Biasanya, Anda harus menggunakan qualifier ukuran dan orientasi untuk menyediakan sumber daya layout alternatif serta menggunakan qualifier kepadatan untuk menyediakan alternatif sumber daya dapat digambar berupa bitmap.
Bagian berikut merangkum cara bagaimana Anda ingin menggunakan qualifier kepadatan dan ukuran masing-masing untuk menyediakan layout alternatif dan sumber daya dapat digambar.
Layout alternatif
Umumnya, Anda akan mengetahui apakah perlu layout alternatif untuk ukuran layar berbeda setelah menguji aplikasi pada konfigurasi layar berbeda. Misalnya:
- Saat menguji pada layar kecil, Anda mungkin menemukan bahwa layout tersebut tidak begitu pas pada layar. Misalnya, sebaris tombol mungkin tidak pas dengan lebar layar di perangkat berlayar kecil. Dalam hal ini Anda harus menyediakan layout alternatif untuk layar kecil yang akan menyesuaikan ukuran atau posisi tombol.
- Saat menguji pada layar ekstra-besar, Anda mungkin menyadari bahwa layout Anda tidak efisien dalam menggunakan
layar TV dan direntang secara kentara untuk mengisi layar.
Dalam hal ini, Anda harus menyediakan layout alternatif bagi layar ekstra-besar yang menyediakan
UI desain ulang yang dioptimalkan untuk layar lebih besar seperti tablet.
Walaupun aplikasi Anda seharusnya berfungsi dengan baik tanpa layout alternatif di layar TV, namun bagi pengguna penampilan aplikasi sama pentingnya dengan aplikasi yang didesain secara khusus untuk perangkat mereka. Jika UI dibentang secara kentara, pengguna akan lebih cenderung tidak puas dengan pengalaman menggunakan aplikasi.
- Dan, saat menguji di orientasi lanskap dibandingkan dengan orientasi potret, Anda mungkin melihat bahwa elemen UI ditempatkan di bagian bawah layar untuk orientasi potret padahal seharusnya di sisi kanan layar dalam orientasi lanskap.
Ringkasnya, Anda harus memastikan bahwa layout aplikasi:
- Pas di layar kecil (sehingga pengguna bisa benar-benar menggunakan aplikasi Anda)
- Dioptimalkan untuk layar lebih besar guna memanfaatkan ruang layar tambahan
- Dioptimalkan untuk orientasi potret maupun lanskap
Jika UI Anda menggunakan bitmap yang harus pas dengan ukuran tampilan sekalipun setelah sistem menskalakan layout (misalnya gambar latar belakang untuk tombol), Anda harus menggunakan file bitmap Nine-Patch. File Nine-Patch pada dasarnya adalah file PNG yang Anda gunakan untuk menetapkan region dua dimensi yang dapat direntang. Bila sistem perlu menskalakan tampilan yang akan menggunakan bitmap, sistem akan merentang bitmap Nine-Patch, namun hanya merentang region yang ditetapkan. Dengan demikian, Anda tidak perlu menyediakan sumber daya dapat digambar yang berbeda untuk ukuran layar berbeda, karena bitmap Nine-Patch bisa menyesuaikan dengan ukuran apa saja. Akan teapi, Anda harus menyediakan versi alternatif untuk file Nine-Patch bagi kepadatan layar berbeda.
Alternatif sumber daya dapat digambar

Gambar 4. Ukuran relatif sumber daya dapat digambar berupa bitmap yang mendukung setiap kepadatan.
Hampir setiap aplikasi harus memiliki alternatif sumber daya dapat digambar untuk kepadatan layar yang berbeda, karena hampir setiap aplikasi memiliki ikon peluncur dan ikon itu harus terlihat dengan baik pada semua kepadatan layar. Demikian pula, jika Anda menyertakan sumber daya dapat digambar berupa bitmap lainnya dalam aplikasi (misalnya untuk ikon menu atau grafik lainnya dalam aplikasi), Anda harus menyediakan versi alternatif atau masing-masing satu, untuk kepadatan yang berbeda.
Catatan: Anda hanya perlu menyediakan sumber daya dapat digambar yang berkepadatan spesifik untuk
file bitmap (.png
, .jpg
, atau .gif
) dan file Nine-Patch (.9.png
). Jika Anda menggunakan file XML to mendefinisikan bentuk, warna, atau sumber daya dapat digambar lainnya, Anda harus menempatkan
satu salinannya dalam direktori default sumber daya dapat digambar (drawable/
).
Untuk membuat sumber daya dapat digambar berupa bitmap bagi kepadatan berbeda, Anda harus mengikuti rasio penskalaan 3:4:6:8:12:16 di antara enam kepadatan umum. Misalnya, jika Anda memiliki sumber daya dapat digambar berupa bitmap 48x48 piksel untuk layar berkepadatan medium, semua ukuran yang berbeda harus menjadi:
- 36x36 (0,75x) untuk layar berkepadatan rendah
- 48x48 (patokan 1,0x) untuk layar berkepadatan medium
- 72x72 (1,5x) untuk layar berkepadatan tinggi
- 96x96 (2,0x) untuk layar berkepadatan ekstra-tinggi
- 144x144 (3,0x) untuk layar berkepadatan ekstra-ekstra-tinggi
- 192x192 (4,0x) untuk layar berkepadatan ekstra-ekstra-ekstra-tinggi (hanya ikon peluncur; lihat catatan di atas)
Untuk informasi selengkapnya tentang mendesain ikon, lihat Panduan Desain Ikon, yang menyertakan informasi ukuran untuk beragam sumber daya dapat digambar berupa bitmap, misalnya ikon peluncur, ikon menu, ikon bilah status, ikon tab, dan lainnya.
Mendeklarasikan Layout Tablet untuk Android 3.2
Untuk tablet generasi pertama yang menjalankan Android 3.0, cara tepat untuk mendeklarasikan
layout tablet adalah memasukkannya dalam direktori bersama qualifier konfigurasi xlarge
(misalnya,
res/layout-xlarge/
). Untuk mengakomodasi tipe tablet dan ukuran layar
lainnya—terutama, tablet 7"—Android 3.2 memperkenalkan cara baru untuk menetapkan sumber daya
bagi ukuran layar yang lebih berbeda. Teknik baru tersebut berdasarkan jumlah ruang yang diperlukan layout Anda
(misalnya selebar 600 dp), daripada mencoba membuat layout Anda pas dengan sekelompok ukuran umum
(misalnya besar atau ekstra besar).
Alasan mendesain untuk tablet 7" penuh trik saat menggunakan kelompok ukuran umum bahwa tablet 7" secara teknis berada dalam kelompok yang sama dengan handset 5" (kelompok besar). Walaupun kedua perangkat ini kelihatannya mirip satu sama lain dalam hal ukuran, jumlah ruang untuk UI aplikasi banyak berbeda, karena merupakan gaya interaksi pengguna. Sehingga, layar 7" dan 5" tidak boleh selalu menggunakan layout yang sama. Agar Anda dapat menyediakan layout berbeda untuk kedua macam layar ini, Android kini memungkinkan Anda menetapkan sumber daya layout berdasarkan lebar dan/atau tinggi yang sebenarnya tersedia bagi layout aplikasi Anda, yang ditetapkan satuan dp.
Misalnya, setelah mendesain yang ingin Anda gunakan untuk perangkat bergaya tablet, Anda mungkin mengetahui bahwa layout berhenti bekerja dengan baik bila lebar layar kurang dari 600 dp. Sehingga nilai ambang ini menjadi ukuran minimum yang diperlukan untuk layout tablet Anda. Dengan demikian, Anda kini bisa menetapkan bahwa sumber daya layout ini harus digunakan hanya bila ada lebar minimal 600 dp untuk UI aplikasi Anda.
Anda harus memilih lebar dan mendesain untuk lebar itu sebagai ukuran minimum, atau menguji berapa lebar terkecil yang didukung layout Anda setelah selesai.
Catatan: Ingatlah bahwa semua angka yang digunakan bersama API ukuran baru ini adalah nilai piksel berkepadatan independen (dp) dan dimensi layout Anda juga harus selalu didefinisikan menggunakan satuan dp, karena yang perlu Anda perhatikan adalah jumlah ruang layar yang tersedia setelah sistem mempertimbangkan kepadatan layar (kebalikan dari menggunakan resolusi piksel mentah). Untuk informasi selengkapnya tentang piksel berkepadatan independen, baca Istilah dan konsep, di awal dokumen ini.
Menggunakan qualifier ukuran baru
Konfigurasi sumber daya berbeda yang bisa Anda tetapkan berdasarkan ruang yang tersedia bagi layout Anda dirangkum dalam tabel 2. Semua qualifier baru ini menawarkan kontrol lebih besar atas ukuran layar spesifik yang didukung oleh aplikasi Anda, dibandingkan dengan kelompok ukuran layar pada umumnya (kecil, normal, besar, dan ekstra-besar).
Catatan: Ukuran yang Anda tetapkan menggunakan qualifier ini bukan ukuran layar sesungguhnya. Melainkan, ukuran untuk lebar atau tinggi dalam satuan dp yang tersedia untuk jendela aktivitas Anda. Sistem Android mungkin menggunakan sebagian layar untuk UI sistem (misalnya bilah sistem di bagian bawah layar atau bilah status di bagian atas), jadi sebagian layar mungkin tidak tersedia untuk layout Anda. Sehingga, ukuran yang Anda deklarasikan harus spesifik tentang ukuran yang diperlukan oleh aktivitas—sistem memperhitungkan ruang yang digunakan oleh UI sistem saat mendeklarasikan banyaknya ruang yang disediakannya untuk layout Anda. Juga ketahuilah bahwa Bilah Aksi dianggap bagian dari ruang jendela aplikasi Anda, walaupun layout Anda tidak mendeklarasikannya, jadi itu akan mengurangi ruang yang tersedia untuk layout dan Anda harus memperhitungkannya dalam desain.
Tabel 2. Qualifier konfigurasi baru untuk ukuran layar (diperkenalkan dalam Android 3.2).
Konfigurasi layar | Nilai-nilai qualifier | Keterangan |
---|---|---|
smallestWidth | sw<N>dp Contoh: sw600dp sw720dp |
Ukuran dasar layar, sebagaimana yang ditunjukkan oleh dimensi terpendek dari area layar
yang tersedia. Khususnya, smallestWidth perangkat adalah yang terpendek dari
tinggi dan lebar layar yang tersedia (Anda dapat menganggapnya sebagai "lebar terkecil yang memungkinkan" untuk layar). Anda bisa
menggunakan qualifier ini untuk memastikan bahwa, apa pun orientasi layar saat ini, aplikasi
Anda memiliki paling tidak Misalnya, jika layout mengharuskan dimensi layar terkecilnya setiap saat paling tidak
600 dp, maka Anda bisa menggunakan qualifier ini untuk membuat sumber daya layout, SmallestWidth perangkat memperhitungkan dekorasi layar dan UI sistem. Misalnya , jika perangkat memiliki beberapa elemen UI persisten pada layar yang menghitung ruang di sepanjang sumbu smallestWidth, sistem akan mendeklarasikan smallestWidth lebih kecil daripada ukuran layar sebenarnya, karena piksel layar itu tidak tersedia untuk UI Anda. Ini adalah alternatif untuk qualifier ukuran layar umum (kecil, normal, besar, ekstra-besar) yang memungkinkan Anda mendefinisikan angka terpisah untuk ukuran efektif yang tersedia bagi UI. Penggunaan smallestWidth untuk menentukan ukuran layar umum berguna karena lebar sering kali menjadi faktor penentu dalam mendesain layout. UI akan sering bergulir secara vertikal, namun memiliki batasan cukup keras atas ruang minimum yang diperlukannya secara horizontal. Lebar yang tersedia juga merupakan faktor penting dalam menentukan apakah akan menggunakan layout satu panel untuk handset ataukah layout multipanel untuk tablet. Sehingga, mungkin Anda paling memperhatikan tentang berapakah lebar terkecil yang memungkinkan pada setiap perangkat. |
Lebar layar yang tersedia | w<N>dp Contoh: w720dp w1024dp |
Menetapkan lebar minimum yang tersedia dalam satuan dp yang harus digunakan
sumber daya—yang didefinisikan oleh nilai Hal ini sering kali berguna untuk menentukan apakah akan menggunakan layout multipanel, karena pada perangkat tablet sekalipun, sering kali Anda tidak akan menginginkan layout multipanel yang sama untuk orientasi potret seperti yang Anda lakukan untuk lanskap. Jadi, Anda bisa menggunakannya untuk menetapkan lebar minimum diperlukan untuk layout, sebagai ganti menggunakan kedua qualifier ukuran layar dan orientasi bersama-sama. |
Tinggi layar yang tersedia | h<N>dp Contoh: h720dp h1024dp dll. |
Menetapkan tinggi layar minimum dalam satuan dp yang harus digunakan
sumber daya—yang didefinisikan oleh nilai Penggunaannya untuk mendefinisikan
tinggi yang diperlukan oleh layout Anda berguna sebagaimana |
Saat menggunakan qualifier ini mungkin kelihatannya lebih rumit daripada menggunakan kelompok ukuran layar, seharusnya ini lebih sederhana setelah Anda menentukan persyaratan UI. Bila Anda mendesain UI, hal utama yang mungkin Anda pedulikan adalah ukuran sesungguhnya yang digunakan aplikasi Anda untuk beralih di antara UI bergaya handset dan UI bergaya tablet yang menggunakan multipanel. Titik persis dari peralihan ini akan bergantung pada desain khusus Anda—mungkin Anda perlu lebar 720 dp untuk layout tablet, mungkin 600 dp sudah cukup, atau 480 dp, atau nilai yang ada di antaranya. Dengan menggunakan qualifier ini dalam tabel 2, Anda akan bisa mengontrol ukuran persis untuk perubahan layout.
Untuk pembahasan selengkapnya tentang qualifier konfigurasi ukuran ini, lihat dokumen Menyediakan Sumber Daya.
Contoh konfigurasi
Untuk membantu Anda menargetkan desain bagi tipe perangkat yang berbeda, inilah beberapa angka untuk lebar layar pada umumnya:
- 320 dp: layar ponsel pada umumnya (240x320 ldpi, 320x480 mdpi, 480x800 hdpi, dll).
- 480 dp: tablet tanggung seperti Streak (480x800 mdpi).
- 600 dp: tablet 7” (600x1024 mdpi).
- 720 dp: tablet 10” (720x1280 mdpi, 800x1280 mdpi, dll).
Menggunakan qualifier ukuran dari tabel 2, aplikasi Anda bisa beralih di antara sumber daya layout yang berbeda untuk handset dan tablet dengan menggunakan angka yang Anda inginkan untuk lebar dan/atau tinggi. Misalnya, jika 600 dp adalah lebar terkecil yang tersedia yang didukung oleh layout tablet, Anda bisa menyediakan kedua set layout ini:
res/layout/main_activity.xml # For handsets res/layout-sw600dp/main_activity.xml # For tablets
Dalam hal ini, lebar terkecil dari ruang layar yang tersedia harus 600 dp agar layout tablet bisa diterapkan.
Untuk kasus lainnya di mana Anda ingin menyesuaikan UI lebih jauh untuk membedakan antar ukuran misalnya tablet 7” dan 10”, Anda bisa mendefinisikan layout lebar terkecil tambahan:
res/layout/main_activity.xml # For handsets (smaller than 600dp available width) res/layout-sw600dp/main_activity.xml # For 7” tablets (600dp wide and bigger) res/layout-sw720dp/main_activity.xml # For 10” tablets (720dp wide and bigger)
Perhatikan bahwa dua set sumber daya contoh sebelumnya menggunakan qualifier "lebar terkecil", sw<N>dp
, yang menetapkan dua sisi layar terkecil, apa pun
orientasi saat ini di perangkat. Jadi, menggunakan sw<N>dp
adalah cara sederhana untuk menetapkan
ukuran layar keseluruhan yang tersedia untuk layout Anda dengan mengabaikan orientasi layar.
Akan tetapi, di beberapa kasus, apa yang mungkin penting bagi layout Anda adalah sebenarnya adalah seberapa besar lebar atau tinggi yang saat ini tersedia. Misalnya, jika Anda memiliki layout dua-panel dengan dua fragmen berdampingan, Anda mungkin ingin menggunakannya bilamana layar menyediakan lebar minimal 600 dp, baik perangkat tersebut dalam orientasi potret maupun lanskap. Dalam hal ini, sumber daya mungkin terlihat seperti ini:
res/layout/main_activity.xml # For handsets (smaller than 600dp available width) res/layout-w600dp/main_activity.xml # Multi-pane (any screen with 600dp available width or more)
Perhatikan, set kedua menggunakan qualifier "lebar yang tersedia", w<N>dp
. Dengan
cara ini, satu perangkat mungkin sebenarnya menggunakan kedua layout, bergantung pada orientasi layar (jika
lebar yang tersedia minimal 600 dp di satu orientasi dan kurang dari 600 dp di
orientasi lain).
Jika tinggi yang tersedia menjadi persoalan, Anda bisa melakukan hal yang sama menggunakan qualifier h<N>dp
. Atau, bahkan mengombinasikan qualifier w<N>dp
dan h<N>dp
jika Anda perlu benar-benar spesifik.
Mendeklarasikan dukungan ukuran layar
Setelah mengimplementasikan layout untuk beberapa ukuran layar berbeda, tidak kalah pentingnya bagi Anda mendeklarasikan layar mana yang didukung aplikasi Anda dalam file manifes.
Bersama qualifier konfigurasi baru untuk ukuran layar, Android 3.2 memperkenalkan beberapa atribut baru untuk elemen manifes <supports-screens>:
-
android:requiresSmallestWidthDp
- Menetapkan smallestWidth minimum yang diperlukan. smallestWidth adalah dimensi terpendek
ruang layar (dalam satuan
dp
) yang harus tersedia untuk UI aplikasi Anda—yaitu, yang terpendek dari dua dimensi layar yang tersedia. Jadi, agar perangkat dianggap kompatibel dengan aplikasi Anda, smallestWidth perangkat tersebut harus sama dengan atau lebih besar dari nilai ini. (Biasanya, nilai yang Anda berikan untuk ini adalah "lebar terkecil" yang didukung layout Anda, apa pun orientasi layar saat ini.)Misalnya, jika aplikasi Anda hanya untuk perangkat bergaya tablet dengan lebar terkecil yang tersedia 600 dp:
<manifest ... > <supports-screens android:requiresSmallestWidthDp="600" /> ... </manifest>
Akan tetapi, jika aplikasi Anda mendukung semua ukuran layar yang didukung oleh Android (hingga sekecil 426 dp x 320 dp), maka Anda tidak perlu mendeklarasikan atribut ini, karena lebar terkecil yang diperlukan aplikasi Anda adalah lebar terkecil yang dimungkinkan pada suatu perangkat.
Perhatian: Sistem Android tidak memperhatikan atribut ini, jadi tidak memengaruhi perilaku aplikasi Anda pada waktu proses. Melainkan, digunakan untuk mengaktifkan pemfilteran bagi aplikasi Anda pada layanan seperti Google Play. Akan tetapi, Google Play saat ini tidak mendukung atribut ini untuk pemfilteran (pada Android 3.2), jadi Anda tetap harus menggunakan atribut ukuran lainnya jika aplikasi Anda tidak mendukung layar kecil.
-
android:compatibleWidthLimitDp
- Atribut ini memungkinkan Anda mengaktifkan mode kompatibilitas layar sebagai
fitur opsional pengguna dengan menetapkan "lebar terkecil" maksimum yang
didukung aplikasi Anda. Jika sisi terkecil pada layar yang tersedia di perangkat lebih besar dari nilai Anda di sini,
pengguna tetap bisa memasang aplikasi Anda, namun akan ditawari untuk menjalankannya di mode kompatibilitas layar. Secara default,
mode kompatibilitas layar dinonaktifkan dan layout diubah ukurannya agar pas dengan layar
seperti biasa, namun sebuah tombol akan tersedia di bilah sistem yang memungkinkan pengguna beralih
mode kompatibilitas layar.
Catatan: Jika layout aplikasi Anda berubah ukurannya dengan benar untuk layar besar, maka Anda tidak perlu menggunakan atribut ini. Kami menyarankan Anda menghindari atribut ini dan sebagai gantinya pastikan layout berubah ukurannya untuk layar yang lebih besar dengan mengikuti saran dalam dokumen ini.
-
android:largestWidthLimitDp
- Atribut ini memungkinkan Anda mengaktifkan paksa mode kompatibilitas layar dengan
menetapkan "lebar terkecil" maksimum yang didukung aplikasi Anda. Jika sisi terkecil
layar yang tersedia di perangkat lebih besar dari nilai Anda di sini, aplikasi akan dijalankan dalam
mode kompatibilitas layar tanpa ada cara bagi pengguna untuk menonaktifkannya.
Catatan: Jika layout aplikasi Anda berubah ukurannya dengan benar untuk layar besar, maka Anda tidak perlu menggunakan atribut ini. Kami menyarankan Anda menghindari atribut ini dan sebagai gantinya pastikan layout berubah ukurannya untuk layar yang lebih besar dengan mengikuti saran dalam dokumen ini.
Perhatian: Saat mengembangkan untuk Android 3.2 dan yang lebih tinggi, Anda tidak boleh menggunakan atribut ukuran layar yang lebih lama bersama atribut yang tercantum di atas. Menggunakan atribut baru dan atribut ukuran yang lebih lama dapat menyebabkan perilaku yang tak diharapkan.
Untuk informasi selengkapnya tentang setiap atribut ini, ikuti masing-masing tautan di atas.
Praktik Terbaik
Sasaran mendukung multilayar adalah untuk membuat aplikasi yang bisa berfungsi dengan benar dan terlihat bagus pada konfigurasi layar umum yang didukung oleh Android. Bagian sebelumnya dari dokumen ini menyediakan informasi tentang cara Android mengadaptasikan aplikasi Anda dengan konfigurasi layar dan bagaimana Anda bisa menyesuaikan penampilan aplikasi di berbagai konfigurasi layar. Bagian ini menyediakan sejumlah tip tambahan dan ringkasan mengenai teknik-teknik yang akan membantu memastikan aplikasi Anda diskalakan dengan benar untuk konfigurasi layar berbeda.
Inilah daftar periksa cepat tentang bagaimana Anda bisa memastikan bahwa aplikasi Anda ditampilkan dengan benar pada beragam layar:
- Gunakan satuan
wrap_content
,match_parent
, ataudp
saat menetapkan dimensi dalam file layout XML - Jangan gunakan nilai piksel hard-code dalam kode aplikasi Anda
- Jangan gunakan
AbsoluteLayout
(tidak digunakan lagi) - Sediakan alternatif sumber daya dapat digambar berupa bitmap untuk kepadatan layar berbeda
Bagian berikut menyediakan detail lebih banyak.
1. Gunakan wrap_content, match_parent, atau satuan dp untuk dimensi layout
Saat mendefinisikan android:layout_width
dan android:layout_height
untuk
tampilan dalam file layout XML, menggunakan "wrap_content"
,
"match_parent"
atau satuan dp
akan menjamin bahwa tampilan
diberikan ukuran yang sesuai pada layar perangkat saat ini.
Sebagai contoh, tampilan dengan layout_width="100dp"
diukur lebarnya 100 piksel pada
layar berkepadatan medium dan sistem akan menaikkan skalanya ke lebar 150 piksel pada layar berkepadatan tinggi, sehingga
tampilan tersebut menempati ruang fisik yang kurang-lebih sama pada layar.
Demikian pula, Anda harus mengutamakan sp
(piksel yang tidak bergantung skala) untuk mendefinisikan
ukuran teks. Faktor skala sp
bergantung pada setelan pengguna dan sistem akan menskalakan
ukurannya sama seperti yang dilakukannya untuk dp
.
2. Jangan gunakan nilai piksel hard-code dalam kode aplikasi Anda
Karena alasan kinerja dan agar kode tetap sederhana, sistem Android menggunakan piksel sebagai
satuan standar untuk menyatakan nilai dimensi atau koordinat. Itu berarti dimensi
tampilan selalu dinyatakan dalam kode menggunakan piksel, namun selalu berdasarkan pada kepadatan layar saat ini.
Sebagai contoh, jika myView.getWidth()
mengembalikan 10, lebar tampilan menjadi 10 piksel pada
layar saat ini, namun pada perangkat yang memiliki layar berkepadatan lebih tinggi, nilai yang dikembalikan mungkin 15. Jika Anda menggunakan
nilai piksel dalam kode aplikasi untuk menangani bitmap yang belum diskalakan secara dini untuk
kepadatan layar saat ini, Anda mungkin perlu menskalakan nilai piksel yang digunakan dalam kode agar cocok dengan
sumber bitmap yang tidak diskalakan.
Jika aplikasi Anda memanipulasi bitmap atau menangani nilai piksel pada waktu proses, lihat bagian di bawah ini tentang Pertimbangan Tambahan mengenai Kepadatan.
3. Jangan gunakan AbsoluteLayout
Tidak seperti widget layout lainnya, AbsoluteLayout
memberlakukan
penggunaan posisi tetap untuk menata letak tampilan anaknya, yang bisa dengan mudah menyebabkan antarmuka pengguna menjadi
tidak berfungsi dengan baik pada tampilan lain. Karena itu, AbsoluteLayout
tidak digunakan lagi
di Android 1.5 (API Level 3).
Sebagai gantinya Anda harus menggunakan RelativeLayout
, yang menggunakan pemosisian relatif
untuk menata letak tampilan anak. Sebagai contoh, Anda bisa menetapkan bahwa widget tombol harus muncul "di
sebelah kanan" widget teks.
4. Gunakan ukuran dan sumber daya kepadatan spesifik
Walaupun sistem menskalakan layout dan sumber daya dapat digambar berdasarkan konfigurasi layar saat ini, Anda mungkin ingin membuat penyesuaian pada UI di ukuran layar yang berbeda dan menyediakan sumber daya dapat digambar berupa bitmap yang dioptimalkan untuk kepadatan berbeda. Pada dasarnya ini mengulang informasi dari bagian sebelumnya di dokumen ini.
Jika Anda perlu mengontrol secara persis bagaimana penampilan aplikasi Anda pada beragam konfigurasi layar, sesuaikan layout dan sumber daya dapat digambar berupa bitmap dalam direktori sumber daya dapat digambar berupa bitmap yang spesifik. Misalnya, pertimbangkan ikon yang ingin Anda tampilkan pada layar berkepadatan tinggi dan medium. Cukup buat ikon Anda pada dua ukuran berbeda (sebagai contoh 100x100 untuk kepadatan medium dan 150x150 untuk kepadatan tinggi) dan masukkan kedua variasi dalam direktori yang sesuai, menggunakan qualifier yang tepat:
res/drawable-mdpi/icon.png //for medium-density screens res/drawable-hdpi/icon.png //for high-density screens
Catatan: Jika qualifier kepadatan tidak didefinisikan dalam nama direktori, sistem akan beranggapan bahwa sumber daya dalam direktori itu didesain untuk kepadatan medium patokan dan akan diskalakan untuk kepadatan lain dengan semestinya.
Untuk informasi selengkapnya tentang qualifier konfigurasi yang valid, lihat Menggunakan qualifier konfigurasi, di bagian awal dalam dokumen ini.
Pertimbangan Tambahan mengenai Kepadatan
Bagian ini menjelaskan selengkapnya tentang cara Android melakukan penskalaan untuk sumber daya dapat digambar berupa bitmap pada kepadatan layar berbeda dan bagaimana Anda bisa mengontrol lebih jauh cara menggambar bitmap pada kepadatan berbeda. Informasi di bagian ini seharusnya tidak penting untuk sebagian besar aplikasi, kecuali jika Anda mengalami masalah di aplikasi saat menjalankan pada kepadatan layar yang berbeda atau aplikasi Anda memanipulasi grafik.
Untuk memahami lebih baik tentang bagaimana Anda bisa mendukung beberapa kepadatan sekaligus saat memanipulasi grafik pada waktu proses, Anda harus memahami bahwa sistem membantu memastikan skala yang tepat untuk bitmap dengan cara berikut:
- Penskalaan dini terhadap sumber daya (misalnya sumber daya dapat digambar berupa bitmap)
Berdasarkan pada kepadatan layar saat ini, sistem menggunakan sumber daya kepadatan atau ukuran spesifik dari aplikasi Anda dan menampilkannya tanpa penskalaan. Jika sumber daya tidak tersedia dalam kepadatan yang benar, sistem akan memuat sumber daya default dan menaikkan atau menurunkan skalanya sebagaimana diperlukan agar cocok dengan kepadatan layar saat ini. Sistem beranggapan bahwa sumber daya default (sumber daya dari suatu direktori tanpa qualifier konfigurasi) didesain untuk kepadatan layar patokan (mdpi), kecuali jika dimuat dari direktori sumber daya kepadatan spesifik. Penskalaan dini adalah apa yang dilakukan sistem saat mengubah ukuran bitmap ke ukuran yang sesuai untuk kepadatan layar saat ini.
Jika Anda meminta dimensi sumber daya yang telah diskalakan dini, sistem akan mengembalikan nilai yang mewakili dimensi tersebut setelah penskalaan. Misalnya, bitmap yang didesain pada 50x50 piksel untuk layar mdpi akan diskalakan ke 75x75 piksel pada layar hdpi layar (jika tidak ada sumber daya alternatif untuk hdpi) dan sistem akan melaporkan ukuran demikian.
Ada beberapa situasi yang mungkin membuat Anda tidak ingin Android melakukan penskalaan dini terhadap sumber daya. Cara termudah untuk menghindari penskalaan dini adalah memasukkan sumber daya dalam direktori sumber daya bersama qualifier konfigurasi
nodpi
. Misalnya:res/drawable-nodpi/icon.png
Bila sistem menggunakan bitmap
icon.png
dari folder ini, sistem tidak akan menskalakannya berdasarkan kepadatan perangkat saat ini. - Menskalakan otomatis dimensi piksel dan koordinat
Sebuah aplikasi bisa menonaktifkan penskalaan dini dengan menyetel
android:anyDensity
ke"false"
dalam manifes atau lewat program untukBitmap
dengan menyetelinScaled
ke"false"
. Dalam hal ini, sistem akan menskalakan otomatis semua nilai koordinat piksel absolut dan nilai dimensi piksel pada waktu menggambarnya. Sistem melakukannya untuk memastikan elemen layar yang didefinisikan dengan piksel tetap ditampilkan pada ukuran fisik yang kurang-lebih sama karena akan ditampilkan pada kepadatan layar patokan (mdpi). Sistem menangani penskalaan ini secara transparan ke aplikasi dan melaporkan dimensi piksel yang diskalakan ke aplikasi, bukan dimensi piksel fisik.Sebagai contoh, anggaplah sebuah perangkat memiliki layar berkepadatan tinggi WVGA 480x800 dan ukurannya kurang lebih sama dengan layar HVGA biasa, namun perangkat menjalankan aplikasi yang menonaktifkan penskalaan dini. Dalam hal ini, sistem akan "berbohong" kepada aplikasi bila aplikasi menanyakan dimensi layar, dan melaporkan 320x533 (perkiraan terjemahan mdpi untuk kepadatan layar). Kemudian, bila aplikasi melakukan operasi menggambar, misalnya menginvalidkan persegi panjang dari (10,10) hingga (100, 100), sistem akan mentransformasikan koordinat dengan menskalakannya ke jumlah yang sesuai, dan sebenarnya menginvalidkan region (15,15) hingga (150, 150). Perbedaan ini dapat menyebabkan perilaku tak diharapkan jika aplikasi Anda memanipulasi secara langsung bitmap yang telah diskalakan, namun hal ini dianggap konsekuensi wajar untuk menjaga kinerja aplikasi sebaik mungkin. Jika Anda mengalami situasi ini, bacalah bagian berikut tentang Mengonversi satuan dp ke satuan piksel.
Biasanya, Anda tidak boleh menonaktifkan penskalaan dini. Cara terbaik untuk mendukung multilayar adalah mengikuti teknik dasar yang dijelaskan di atas dalam Cara Mendukung Multilayar.
Jika aplikasi Anda memanipulasi bitmap atau berinteraksi secara langsung dengan piksel di layar dengan cara lain, Anda mungkin perlu mengambil langkah tambahan untuk mendukung kepadatan layar yang berbeda. Misalnya, jika Anda merespons isyarat sentuhan dengan menghitung jumlah piksel yang dilewati jari, Anda perlu menggunakan nilai piksel kepadatan independen yang sesuai, sebagai ganti piksel sesungguhnya.
Menskalakan objek bitmap yang dibuat pada waktu proses

Gambar 5. Perbandingan bitmap hasil penskalaan dini dan penskalaan otomatis.
Jika aplikasi Anda membuat bitmap di-memori (objek Bitmap
), sistem
akan beranggapan bahwa bitmap didesain untuk layar berkepadatan medium patokan, secara default, dan
secara otomatis menskalakan bitmap pada waktu menggambar. Sistem akan menerapkan "penskalaan otomatis" pada Bitmap
bila bitmap memiliki properti kepadatan yang tidak ditetapkan. Jika Anda tidak memperhitungkan
dengan benar kepadatan layar perangkat saat ini dan menetapkan properti kepadatan bitmap,
penskalaan otomatis bisa mengakibatkan artefak penskalaan, sama seperti bila Anda tidak menyediakan
sumber daya alternatif.
Untuk mengontrol apakah Bitmap
yang dibuat pada waktu proses akan
diskalakan atau tidak, Anda bisa menetapkan kepadatan bitmap dengan setDensity()
,
meneruskan konstanta kepadatan dari DisplayMetrics
, misalnya DENSITY_HIGH
atau DENSITY_LOW
.
Jika Anda sedang membuat Bitmap
menggunakan BitmapFactory
, misalnya dari file atau aliran, Anda bisa menggunakan BitmapFactory.Options
untuk mendefinisikan properti bitmap sebagai
sudah ada, yang akan menentukan apakah atau bagaimana sistem akan menskalakannya. Misalnya, Anda bisa menggunakan bidang
inDensity
untuk mendefinisikan kepadatan untuk desain
bitmap dan bidang inScaled
untuk menetapkan apakah bitmap harus diskalakan agar
cocok dengan kepadatan layar perangkat saat ini.
Jika Anda menyetel bidang inScaled
ke false
, maka Anda akan menonaktifkan
penskalaan dini yang mungkin akan diterapkan sistem pada bitmap dan sistem kemudian akan menskalakannya
secara otomatis pada waktu menggambar. Menggunakan penskalaan otomatis sebagai ganti penskalaan dini bisa menghabiskan banyak tenaga CPU, namun menggunakan
memori lebih sedikit.
Gambar 5 memperagakan hasil mekanisme penskalaan dini dan penskalaan otomatis saat memuat bitmap berkepadatan rendah (120), medium (160), dan tinggi (240) pada layar berkepadatan tinggi. Perbedaannya tidak kentara, karena semua bitmap akan diskalakan agar cocok dengan kepadatan layar saat ini, akan tetapi bitmap yang diskalakan akan memiliki penampilan yang sedikit berbeda tergantung apakah bitmap tersebut hasil penskalaan dini atau penskalaan otomatis pada waktu menggambar.
Catatan: Di Android 3.0 dan yang lebih tinggi, tidak akan ada perbedaan mencolok antara bitmap hasil penskalaan dini dan penskalaan otomatis, berkat peningkatan dalam kerangka kerja grafik.
Mengonversi satuan dp ke satuan piksel
Dalam beberapa kasus, Anda perlu menyatakan dimensi dalam dp
kemudian mengonversinya ke
piksel. Bayangkan sebuah aplikasi di mana isyarat menggulir atau melontarkan dikenali setelah jari
pengguna berpindah minimal 16 piksel. Pada layar patokan, pengguna harus memindahkan jari sebanyak 16 pixels
/ 160 dpi
, yang sama dengan 1/10 inci (atau 2,5 mm) sebelum isyarat tersebut dikenali. Pada perangkat
yang memiliki tampilan berkepadatan tinggi (240 dpi), jari pengguna harus berpindah sebanyak 16 pixels / 240 dpi
, yang
sama dengan 1/15 inci (atau 1,7 mm). Jarak tersebut jauh lebih pendek dan aplikasi akan tampak
lebih peka pada pengguna.
Untuk memperbaiki masalah ini, nilai ambang isyarat harus dinyatakan dalam kode berupa dp
kemudian
dikonversi ke piksel sesungguhnya. Misalnya:
// The gesture threshold expressed in dp private static final float GESTURE_THRESHOLD_DP = 16.0f; // Get the screen's density scale final float scale =getResources()
.getDisplayMetrics()
.density; // Convert the dps to pixels, based on density scale mGestureThreshold = (int) (GESTURE_THRESHOLD_DP * scale + 0.5f); // Use mGestureThreshold as a distance in pixels...
Bidang DisplayMetrics.density
menetapkan faktor
skala yang harus Anda gunakan untuk mengonversi satuan dp
ke piksel, sesuai dengan kepadatan layar saat ini.
Pada layar berkepadatan medium, DisplayMetrics.density
sama dengan 1,0; pada layar berkepadatan tinggi sama dengan 1,5; pada layar berkepadatan ekstra-tinggi sama dengan 2,0;
dan pada layar berkepadatan rendah sama dengan 0,75. Angka in adalah faktor yang harus Anda kalikan dengan
satuan dp
untuk mendapatkan jumlah piksel sesungguhnya bagi layar saat ini. (Kemudian tambahkan 0.5f
untuk membulatkan angka ke atas ke bilangan bulat terdekat, saat mengonversi ke integer.) Untuk
informasi selengkapnya, lihat kelas DisplayMetrics
.
Akan tetapi, sebagai ganti mendefinisikan ambang bebas untuk jenis kejadian ini, Anda
harus menggunakan nilai konfigurasi penskalaan dini yang tersedia dari ViewConfiguration
.
Menggunakan nilai konfigurasi hasil penskalaan dini
Anda bisa menggunakan kelas ViewConfiguration
untuk mengakses jarak,
kecepatan, dan waktu yang umum digunakan oleh sistem Android. Sebagai contoh, jarak
dalam piksel yang digunakan oleh kerangka kerja sebagai nilai ambang guliran bisa diperoleh dengan getScaledTouchSlop()
:
private static final int GESTURE_THRESHOLD_DP = ViewConfiguration.get(myContext).getScaledTouchSlop();
Metode-metode dalam ViewConfiguration
dimulai dengan awalan getScaled
dijamin
akan mengembalikan nilai dalam piksel yang akan menampilkan kepadatan layar saat ini
dengan benar.
Cara Menguji Aplikasi Anda di Multilayar

Gambar 6. Serangkaian AVD untuk menguji dukungan layar.
Sebelum mempublikasikan aplikasi, Anda harus mengujinya secara saksama di semua ukuran layar dan kepadatan yang didukung. Android SDK menyertakan kulit emulator yang bisa Anda gunakan, yang menirukan ukuran dan kepadatan konfigurasi layar pada umumnya di mana aplikasi Anda nanti akan dijalankan. Anda juga bisa memodifikasi ukuran, kepadatan, dan resolusi default kulit emulator untuk menirukan karakteristik layar tertentu. Penggunaan kulit emulator dan konfigurasi khusus tambahan memungkinkan Anda menguji konfigurasi layar yang memungkinkan, sehingga Anda tidak perlu membeli beragam perangkat cuma untuk menguji dukungan layar aplikasi Anda.
Untuk menyiapkan lingkungan pengujian dukungan layar bagi aplikasi, Anda harus membuat serangkaian AVD (Android Virtual Device), menggunakan kulir emulator dan konfigurasi layar yang menirukan kepadatan dan ukuran layar yang ingin didukung oleh aplikasi Anda. Caranya, Anda bisa menggunakan AVD Manager untuk membuat AVD dan menjalankannya bersama antarmuka grafis.
Untuk menjalankan Android SDK Manager, eksekusi SDK Manager.exe
dari direktori Android SDK (hanya di Windows) atau eksekusi android
dari
direktori <sdk>/tools/
(di semua platform). Gambar 6 menampilkan AVD
Manager dengan beberapa AVD yang dipilih, untuk menguji beragam konfigurasi layar.
Tabel 3 menampilkan beragam kulit emulator yang tersedia di Android SDK, yang bisa Anda gunakan untuk menirukan sebagian besar konfigurasi layar umum.
Untuk informasi selengkapnya tentang membuat dan menggunakan AVD untuk menguji aplikasi, lihat Mengelola AVD dengan AVD Manager.
Tabel 3. Beragam konfigurasi layar yang tersedia dari kulit emulator di Android SDK (ditandai dengan cetak tebal) dan resolusi representatif lainnya.
|
|
|
|
|
---|---|---|---|---|
Layar kecil | QVGA (240x320) | 480x640 | ||
Layar normal | WQVGA400 (240x400)
WQVGA432 (240x432) |
HVGA (320x480) | WVGA800 (480x800)
WVGA854 (480x854) 600x1024 |
640x960 |
Layar besar | WVGA800** (480x800)
WVGA854** (480x854) |
WVGA800* (480x800)
WVGA854* (480x854) 600x1024 |
||
Layar ekstra-besar | 1024x600 | WXGA (1280x800)† 1024x768 1280x768 |
1536x1152 1920x1152 1920x1200 |
2048x1536 2560x1536 2560x1600 |
* Untuk mengemulasikan konfigurasi ini, tetapkan
kepadatan khusus 160 saat membuat AVD yang menggunakan kulit WVGA800 atau WVGA854. ** Untuk mengemulasikan konfigurasi ini, tetapkan kepadatan khusus 120 saat membuat AVD yang menggunakan kulit WVGA800 atau WVGA854. † Kulit ini tersedia pada platform Android 3.0 |
Untuk melihat jumlah relatif perangkat aktif yang mendukung suatu konfigurasi layar, lihat dasbor Kepadatan dan Ukuran Layar.

Gambar 7. Opsi ukuran dan kepadatan yang bisa Anda setel, saat menjalankan AVD dari AVD Manager.
Kami juga menyarankan Anda untuk menguji aplikasi di emulator yang disiapkan untuk dijalankan pada ukuran fisik yang mendekati ukuran di perangkat sesungguhnya. Ini membuatnya jadi jauh lebih mudah membandingkan hasil pada beragam ukuran dan kepadatan. Untuk melakukannya Anda perlu mengetahui perkiraan kepadatan, dalam dpi, monitor komputer Anda (sebagai contoh, monitor Dell 30" memiliki kepadatan sekitar 96 dpi). Bila menjalankan AVD dari AVD Manager, Anda bisa menetapkan ukuran layar bagi emulator dan dpi monitor Anda di Launch Options, seperti yang ditampilkan dalam gambar 7.
Jika Anda ingin menguji aplikasi di layar yang menggunakan resolusi atau kepadatan yang tidak didukung oleh kulit bawaan, Anda bisa membuat AVD yang menggunakan resolusi atau kepadatan khusus. Saat membuat AVD dari AVD Manager, tetapkan Resolution, sebagai ganti memilih Built-in Skin.
Jika menjalankan AVD dari baris perintah, Anda bisa menetapkan skala untuk
emulator dengan opsi -scale
. Misalnya:
emulator -avd <avd_name> -scale 96dpi
Untuk menyaring lebih lanjut ukuran emulator, sebagai gantinya Anda bisa meneruskan opsi -scale
sebuah
angka antara 0,1 dan 3 yang mewakili faktor penskalaan yang diinginkan.
Untuk informasi selengkapnya tentang membuat AVD dari baris perintah, lihat Mengelola AVD dari Baris Perintah.