Save the date! Android Dev Summit is coming to Mountain View, CA on November 7-8, 2018.

Mendukung Beberapa Layar

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: px = dp * (dpi / 160). 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.

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, dan xlarge. Misalnya, layout untuk layar ekstra besar harus masuk dalam layout-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 dalam layout-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), dan xxxhdpi (ekstra-ekstra-ekstra-tinggi). Misalnya, bitmap untuk layar berkepadatan tinggi harus dimasukkan dalam drawable-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:

  1. 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 (misalnya drawable-hdpi/) mungkin menjadi yang paling cocok, jadi sistem menggunakan sumber daya dapat digambar dari direktori ini.

  2. 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:

  1. Buat direktori baru dalam direktori res/ proyek Anda dan beri nama dengan format: <resources_name>-<qualifier>
    • <resources_name> adalah nama sumber daya standar (misalnya drawable atau layout).
    • <qualifier> adalah qualifier konfigurasi dari tabel 1, di bawah, yang menetapkan konfigurasi layar yang akan digunakan bersama sumber daya ini (misalnya hdpi atau xlarge).

    Anda bisa menggunakan lebih dari satu <qualifier> untuk setiap kalinya—cukup dengan memisahkan setiap qualifier dengan tanda hubung.

  2. 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 layarNilai-nilai qualifierKeterangan
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 <N> dps dari lebar yang tersedia untuk UI-nya.

Misalnya, jika layout mengharuskan dimensi layar terkecilnya setiap saat paling tidak 600 dp, maka Anda bisa menggunakan qualifier ini untuk membuat sumber daya layout, res/layout-sw600dp/. Sistem akan menggunakan sumber daya ini hanya bila dimensi layar terkecil yang tersedia paling tidak 600 dp, tanpa mempertimbangkan apakah sisi 600 dp adalah tinggi atau lebar yang dipersepsikan pengguna. SmallestWidth adalah karakteristik ukuran layar tetap dari perangkat; smallestWidth perangkat tidak berubah saat orientasi layar berubah.

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 <N>. Nilai sistem yang sesuai untuk lebar akan berubah bila orientasi layar beralih antara lanskap dan potret untuk mencerminkan lebar sesungguhnya saat ini yang tersedia untuk UI Anda.

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 <N>. Nilai sistem yang bersangkutan untuk tinggi akan berubah bila orientasi layar beralih antara lanskap dan potret untuk mencerminkan tinggi sesungguhnya saat ini yang tersedia untuk UI Anda.

Penggunaannya untuk mendefinisikan tinggi yang diperlukan oleh layout Anda berguna sebagaimana w<N>dp adalah untuk mendefinisikan lebar yang diperlukan, sebagai ganti menggunakan qualifier orientasi dan ukuran layar. Akan tetapi, umumnya aplikasi tidak akan memerlukan qualifier ini, dengan mempertimbangkan bahwa UI sering kali bergulir secara vertikal sehingga akan lebih fleksibel dengan ketinggian yang tersedia, sementara bila lebar akan menjadi lebih kaku.

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:

  1. Gunakan satuan wrap_content, match_parent, atau dp saat menetapkan dimensi dalam file layout XML
  2. Jangan gunakan nilai piksel hard-code dalam kode aplikasi Anda
  3. Jangan gunakan AbsoluteLayout (tidak digunakan lagi)
  4. 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:

  1. 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.

  2. Menskalakan otomatis dimensi piksel dan koordinat

    Sebuah aplikasi bisa menonaktifkan penskalaan dini dengan menyetel android:anyDensity ke "false" dalam manifes atau lewat program untuk Bitmap dengan menyetel inScaled 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.

Kepadatan rendah (120), ldpi Kepadatan medium (160), mdpi Kepadatan tinggi (240), hdpi Kepadatan ekstra-tinggi (320), xhdpi
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.