Apa perbedaan antara unit ukuran Android?

• px
• menukik
• dp
• sp

Dari Dokumentasi Pengembang Android :

1. px
   Pixels - sesuai dengan piksel aktual di layar.

2. dalam
   Inci - berdasarkan pada ukuran fisik layar.
   1 Inch = 2,54 sentimeter

3. mm
   Milimeter - berdasarkan pada ukuran fisik layar.

4. 
   Poin pt - 1/72 inci berdasarkan pada ukuran fisik layar.

5. dp atau celup
   Density -independent Pixels - unit abstrak yang didasarkan pada kepadatan fisik layar. Unit-unit ini relatif terhadap layar 160 dpi, jadi satu dp adalah satu piksel pada layar 160 dpi. Rasio dp-ke-pixel akan berubah dengan kerapatan layar, tetapi tidak harus dalam proporsi langsung. Catatan: Compiler menerima "dip" dan "dp", meskipun "dp" lebih konsisten dengan "sp".

6. Skala sp
   -independent Pixels - ini seperti unit dp, tetapi juga diskalakan oleh preferensi ukuran font pengguna. Disarankan Anda menggunakan unit ini ketika menentukan ukuran font, sehingga mereka akan disesuaikan untuk kepadatan layar dan preferensi pengguna.

Dari Understanding Density Independence In Android :

+----------------+----------------+---------------+-------------------------------+
| Density Bucket | Screen Density | Physical Size | Pixel Size                    | 
+----------------+----------------+---------------+-------------------------------+
| ldpi           | 120 dpi        | 0.5 x 0.5 in  | 0.5 in * 120 dpi = 60x60 px   | 
+----------------+----------------+---------------+-------------------------------+
| mdpi           | 160 dpi        | 0.5 x 0.5 in  | 0.5 in * 160 dpi = 80x80 px   | 
+----------------+----------------+---------------+-------------------------------+
| hdpi           | 240 dpi        | 0.5 x 0.5 in  | 0.5 in * 240 dpi = 120x120 px | 
+----------------+----------------+---------------+-------------------------------+
| xhdpi          | 320 dpi        | 0.5 x 0.5 in  | 0.5 in * 320 dpi = 160x160 px | 
+----------------+----------------+---------------+-------------------------------+
| xxhdpi         | 480 dpi        | 0.5 x 0.5 in  | 0.5 in * 480 dpi = 240x240 px | 
+----------------+----------------+---------------+-------------------------------+
| xxxhdpi        | 640 dpi        | 0.5 x 0.5 in  | 0.5 in * 640 dpi = 320x320 px | 
+----------------+----------------+---------------+-------------------------------+

+---------+-------------+---------------+-------------+--------------------+
| Unit    | Description | Units Per     | Density     | Same Physical Size | 
|         |             | Physical Inch | Independent | On Every Screen    | 
+---------+-------------+---------------+-------------+--------------------+
| px      | Pixels      | Varies        | No          | No                 | 
+---------+-------------+---------------+-------------+--------------------+
| in      | Inches      | 1             | Yes         | Yes                | 
+---------+-------------+---------------+-------------+--------------------+
| mm      | Millimeters | 25.4          | Yes         | Yes                | 
+---------+-------------+---------------+-------------+--------------------+
| pt      | Points      | 72            | Yes         | Yes                | 
+---------+-------------+---------------+-------------+--------------------+
| dp      | Density     | ~160          | Yes         | No                 | 
|         | Independent |               |             |                    | 
|         | Pixels      |               |             |                    | 
+---------+-------------+---------------+-------------+--------------------+
| sp      | Scale       | ~160          | Yes         | No                 | 
|         | Independent |               |             |                    | 
|         | Pixels      |               |             |                    | 
+---------+-------------+---------------+-------------+--------------------+

Info lebih lanjut dapat ditemukan di Dokumentasi Desain Google .

Semuanya tentang hal ini dan cara mendapatkan dukungan terbaik untuk beberapa layar dengan ukuran dan kepadatan berbeda didokumentasikan dengan baik di sini:

• Mendukung Banyak Layar

Ukuran layar Ukuran
fisik sebenarnya, diukur sebagai diagonal layar. Untuk kesederhanaan, Android mengelompokkan semua ukuran layar aktual menjadi empat ukuran umum: kecil, normal, besar, dan ekstra besar.

Kepadatan layar
Jumlah piksel dalam area fisik layar; biasanya disebut sebagai dpi (dots per inch). Misalnya, layar kepadatan "rendah" memiliki piksel lebih sedikit dalam area fisik tertentu, dibandingkan dengan layar kepadatan "normal" atau "tinggi". Untuk kesederhanaan, Android mengelompokkan semua kepadatan layar aktual menjadi enam kepadatan umum: rendah, sedang, tinggi, ekstra-tinggi, ekstra-ekstra-tinggi, dan ekstra-ekstra-ekstra-tinggi.

Orientasi
Orientasi layar dari sudut pandang pengguna. Ini adalah lanskap atau potret, yang berarti bahwa rasio aspek layar masing-masing lebar atau tinggi. Ketahuilah bahwa tidak hanya perangkat yang berbeda beroperasi dalam orientasi yang berbeda secara default, tetapi orientasi dapat berubah saat runtime ketika pengguna memutar perangkat.

Resolusi
Jumlah total piksel fisik pada layar. Saat menambahkan dukungan untuk beberapa layar, aplikasi tidak bekerja secara langsung dengan resolusi; aplikasi harus hanya memperhatikan ukuran layar dan kepadatan, seperti yang ditentukan oleh kelompok ukuran dan kepadatan umum.

Density-independent pixel (dp)
Satuan pixel virtual yang harus Anda gunakan ketika mendefinisikan tata letak UI, untuk mengekspresikan dimensi atau posisi tata letak dengan cara yang tidak tergantung kepadatan. Pixel independen-kepadatan setara dengan satu pixel fisik pada layar 160 dpi, yang merupakan kepadatan awal yang diasumsikan oleh sistem untuk layar kepadatan "sedang". Saat runtime, sistem secara transparan menangani penskalaan unit dp, sebagaimana diperlukan, berdasarkan kepadatan aktual layar yang digunakan. Konversi unit dp untuk piksel layar sederhana: px = dp * (dpi / 160). Misalnya, pada layar 240 dpi, 1 dp sama dengan 1,5 piksel fisik. Anda harus selalu menggunakan unit dp saat menentukan UI aplikasi Anda, untuk memastikan tampilan UI Anda dengan benar pada layar dengan kepadatan berbeda.

Jika Anda serius mengembangkan aplikasi Android untuk lebih dari satu jenis perangkat, Anda harus membaca layar mendukung dokumen pengembangan setidaknya satu kali. Selain itu, selalu baik untuk mengetahui jumlah aktual perangkat aktif yang memiliki konfigurasi layar tertentu.

• Ukuran Layar dan Kepadatan

Saya akan menguraikan lebih lanjut tentang bagaimana tepatnya konversi dp ke px:

• Jika berjalan pada perangkat mdpi, 150 x 150 pxgambar akan mengambil 150 * 150 dpruang layar.
• Jika berjalan pada perangkat hdpi, 150 x 150 pxgambar akan memakan 100 * 100 dpruang layar.
• Jika berjalan pada perangkat xhdpi, 150x150 pxgambar akan memakan 75 * 75 dpruang layar.

Sebaliknya: katakanlah, Anda ingin menambahkan gambar ke aplikasi Anda dan Anda memerlukannya untuk mengisi 100 * 100 dpkontrol. Anda harus membuat gambar dengan ukuran berbeda untuk ukuran layar yang didukung:

• 100 * 100 px gambar untuk mdpi
• 150 * 150 px gambar untuk hdpi
• 200 * 200 px gambar untuk xhdpi

px - Piksel - titik per skala sesuai dengan piksel aktual di layar.

i - Inches - berdasarkan pada ukuran fisik layar.

mm - Milimeter - berdasarkan pada ukuran fisik layar.

pt - Poin - 1/72 inci berdasarkan pada ukuran fisik layar.

dp - Pixel-Density-independent - unit abstrak yang didasarkan pada kepadatan fisik layar. Unit-unit ini relatif terhadap layar 160 dpi, jadi satu dpadalah satu piksel pada layar 160 dpi. Rasio dp-ke-pixel akan berubah dengan kerapatan layar, tetapi tidak harus dalam proporsi langsung. Catatan: Kompilator menerima keduanya dipdan dp, meskipun dplebih konsisten dengan sp.

sp - Skala-independen Pixels - ini seperti dpunit, tetapi juga diskalakan oleh preferensi ukuran font pengguna. Anda disarankan untuk menggunakan unit ini ketika menentukan ukuran font, sehingga mereka akan disesuaikan untuk kepadatan layar dan preferensi pengguna.

Ambil contoh dua layar dengan ukuran yang sama tetapi satu memiliki kepadatan layar 160 dpi (titik per inci, yaitu piksel per inci) dan yang lainnya adalah 240 dpi.

                          Lower resolution screen     Higher resolution, same size
Physical Width                      1.5 inches                        1.5 inches
Dots Per Inch (“dpi”)               160                               240
Pixels (=width*dpi)                 240                               360
Density (factor of baseline 160)    1.0                               1.5

Density-independent pixels          240                               240
(“dip” or “dp” or “dps”)

Scale-independent pixels 
 (“sip” or “sp”)                  Depends on user font size settings    same

Selain itu, Anda harus memiliki pemahaman yang jelas tentang konsep-konsep berikut:

Ukuran layar:

Ukuran fisik aktual, diukur sebagai diagonal layar. Untuk mempermudah, Android mengelompokkan semua ukuran layar aktual menjadi empat ukuran umum: kecil, normal, besar, dan ekstra besar.

Kepadatan layar:

Jumlah piksel dalam area fisik layar; biasanya disebut sebagai dpi (dots per inch). Misalnya, layar kepadatan "rendah" memiliki piksel lebih sedikit dalam area fisik tertentu, dibandingkan dengan layar kepadatan "normal" atau "tinggi". Untuk kesederhanaan, Android mengelompokkan semua kepadatan layar aktual menjadi empat kepadatan umum: rendah, sedang, tinggi, dan ekstra tinggi.

Orientasi:

Orientasi layar dari sudut pandang pengguna. Ini adalah lanskap atau potret, yang berarti bahwa rasio aspek layar masing-masing lebar atau tinggi. Sadarilah bahwa tidak hanya perangkat yang berbeda beroperasi dalam orientasi yang berbeda secara default, tetapi orientasi dapat berubah saat runtime ketika pengguna memutar perangkat.

Resolusi:

Jumlah total piksel fisik pada layar. Saat menambahkan dukungan untuk beberapa layar, aplikasi tidak bekerja secara langsung dengan resolusi; aplikasi harus hanya memperhatikan ukuran layar dan kepadatan, seperti yang ditentukan oleh kelompok ukuran dan kepadatan umum.

Pixel-independent pixel (dp):

Unit piksel virtual yang harus Anda gunakan saat mendefinisikan tata letak UI, untuk mengekspresikan dimensi atau posisi tata letak dengan cara yang tidak bergantung pada kepadatan. Pixel independen-kepadatan setara dengan satu pixel fisik pada layar 160 dpi, yang merupakan kepadatan awal yang diasumsikan oleh sistem untuk layar kepadatan "sedang". Saat runtime, sistem secara transparan menangani penskalaan unit dp, sebagaimana diperlukan, berdasarkan kepadatan aktual layar yang digunakan. Konversi unit dp ke piksel layar sederhana: px = dp * (dpi / 160). Misalnya, pada layar 240 dpi, 1 dp sama dengan 1,5 piksel fisik. Anda harus selalu menggunakan unit dp saat menentukan UI aplikasi Anda, untuk memastikan tampilan UI Anda dengan benar pada layar dengan kepadatan berbeda.

Referensi: Situs pengembang Android

dpadalah dip. Gunakan untuk semuanya (margin, padding, dll.).

Gunakan hanya spuntuk {ukuran teks}.

Untuk mendapatkan ukuran yang sama pada kepadatan layar yang berbeda, Android menerjemahkan unit-unit ini ke dalam piksel saat runtime, sehingga tidak ada matematika yang rumit untuk Anda lakukan.

Lihat perbedaan antara px, dpdan sppada ukuran layar yang berbeda.

Sumber: Pemrograman Android: Panduan Peternakan Big Nerd

Saya telah menghitung rumus di bawah ini untuk membuat konversi dpike dpdansp

Definisi

px atau dot adalah piksel pada layar fisik.

dpi adalah piksel per inci pada layar fisik dan mewakili kerapatan layar.

Android memberi nama alias ke beberapa kepadatan

• ldpi (rendah) ~ 120dpi
• mdpi (sedang) ~ 160dpi
• hdpi (tinggi) ~ 240dpi
  • sebagian besar perangkat di 2015 ada di sini
• xhdpi (ekstra tinggi) ~ 320dpi
  • Apple iPhone 4/5/6, Nexus 4
• xxhdpi (ekstra-tinggi-tinggi) ~ 480dpi
  • Nexus 5
• xxxhdpi (ekstra-ekstra-ekstra-tinggi) ~ 640dpi

dip atau dp yang kepadatan-indenpendant piksel , yaitu mereka sesuai dengan lebih atau kurang piksel tergantung pada kepadatan fisik.

• 1dp = 1px pada mdpi

sp atau sip adalah piksel skala-independen . Mereka diskalakan ketika opsi Teks Besar dihidupkan di Settings>Accessibility

• 1sp = 1dp
• 1sp = 1.2dp dengan aksesibilitas Teks Besar

Apa yang harus digunakan?

Gunakan sp untuk ukuran teks.

Gunakan dp untuk yang lainnya.

Sumber 1

Sumber 2

Sumber 3 : (data dari sumber 3 diberikan di bawah)

Ini adalah nilai dimensi yang didefinisikan dalam XML. Dimensi ditentukan dengan angka diikuti oleh satuan ukuran. Misalnya: 10px, 2in, 5sp. Unit ukuran berikut ini didukung oleh Android:

dp

Pixel-independent Pixels - Unit abstrak yang didasarkan pada kepadatan fisik layar. Unit-unit ini relatif terhadap layar 160 dpi (dots per inch), di mana 1dp kira-kira sama dengan 1px. Saat dijalankan pada layar dengan kepadatan lebih tinggi, jumlah piksel yang digunakan untuk menggambar 1dp ditingkatkan oleh faktor yang sesuai untuk dpi layar. Demikian juga, ketika pada layar dengan kepadatan lebih rendah, jumlah piksel yang digunakan untuk 1dp diperkecil. Rasio dp-ke-pixel akan berubah dengan kerapatan layar, tetapi tidak harus dalam proporsi langsung. Menggunakan unit dp (bukan unit px) adalah solusi sederhana untuk membuat ukuran tampilan di tata letak Anda diubah ukurannya dengan benar untuk kepadatan layar yang berbeda. Dengan kata lain, ini memberikan konsistensi untuk ukuran dunia nyata elemen UI Anda di berbagai perangkat.

sp

Scale-independent Pixels - Ini seperti unit dp, tetapi juga diskalakan oleh preferensi ukuran font pengguna. Anda disarankan untuk menggunakan unit ini ketika menentukan ukuran font, sehingga mereka akan disesuaikan untuk kepadatan layar dan preferensi pengguna.

pt

Poin - 1/72 inci berdasarkan pada ukuran fisik layar.

px

Piksel - Sesuai dengan piksel aktual di layar. Unit pengukuran ini tidak direkomendasikan karena representasi aktual dapat bervariasi antar perangkat; setiap perangkat mungkin memiliki jumlah piksel yang berbeda per inci dan mungkin memiliki lebih banyak atau lebih sedikit total piksel yang tersedia di layar.

mm

Milimeter - Berdasarkan pada ukuran fisik layar.

di

Inci - Berdasarkan ukuran fisik layar.

Catatan: Dimensi adalah sumber daya sederhana yang direferensikan menggunakan nilai yang disediakan dalam atribut nama (bukan nama file XML). Dengan demikian, Anda dapat menggabungkan sumber daya dimensi dengan sumber daya sederhana lainnya dalam satu file XML, di bawah satu elemen.

Pada dasarnya satu-satunya waktu di mana px berlaku adalah satu px, dan itu jika Anda ingin tepat satu piksel pada layar seperti dalam kasus pembagi:

Pada> 160 dpi, Anda mungkin mendapatkan 2-3 piksel,

Pada> 120 dpi, itu membulat ke 0.

px

Piksel - sesuai dengan piksel aktual di layar.

dp atau celupkan

Pixel-Density-independent - unit abstrak yang didasarkan pada kepadatan fisik layar. Unit-unit ini relatif terhadap layar 160 dpi, jadi satu dp adalah satu piksel pada layar 160 dpi.

Penggunaan dp:

Kemandirian kepadatan - Aplikasi Anda mencapai "kemandirian kepadatan" ketika mempertahankan ukuran fisik (dari sudut pandang pengguna) elemen antarmuka pengguna saat ditampilkan pada layar dengan kepadatan berbeda. (Yaitu) Gambar harus terlihat ukuran yang sama (tidak diperbesar atau menyusut) di berbagai jenis layar.

sp

Skala-independen Pixels - ini seperti unit dp, tetapi juga diskalakan oleh preferensi ukuran font pengguna.

http://developer.android.com/guide/topics/resources/more-resources.html#Dimension

Di mana menggunakan apa & hubungan antara px & dp?

Pixel-independent pixel (dp)

Unit piksel virtual yang harus Anda gunakan saat mendefinisikan tata letak UI, untuk mengekspresikan dimensi atau posisi tata letak dengan cara yang tidak bergantung pada kepadatan. Seperti yang dijelaskan di atas, piksel independen-kepadatan setara dengan satu piksel fisik pada layar 160 dpi, yang merupakan kepadatan awal yang diasumsikan oleh sistem untuk layar kepadatan "sedang". Saat runtime, sistem secara transparan menangani penskalaan unit dp, sebagaimana diperlukan, berdasarkan kepadatan aktual layar yang digunakan. Konversi unit dp ke piksel layar sederhana:

px = dp * (dpi / 160).

Misalnya, pada layar 240 dpi, 1 dp sama dengan 1,5 piksel fisik. Anda harus selalu menggunakan unit dp saat menentukan UI aplikasi Anda, untuk memastikan tampilan UI Anda dengan benar pada layar dengan kepadatan berbeda.

Memahami pixel ke dp dan sebaliknya sangat penting (terutama untuk memberikan nilai dp tepat kepada tim kreatif)

dp = px * 160 / dpi

MDPI = 160 dpi || Therefore, on MDPI 1 px = 1 dp
For example, if you want to convert 20 pixel to dp, use the above formula,
dp = 20 * 160 / 160 = 20.
So, 20 pixel = 20 dp.

HDPI = 240 dpi - So, on HDPI 1.5 px = 1 dp
XHDPI = 320 dpi - So, on XHDPI 2 px = 1 dp
XXHDPI = 480 dpi - So, on XXHDPI 3 px = 1 dp

For example, let us consider Nexus 4.
If 24 pixels to be converted to dp and if it is a Nexus 4 screen, developers can
convert it to dp easily by the following calculation :
dp = 24 * 160 / 320 = 12 dp
Screen dimension:
768 x 1280 pixel resolution (320 ppi or 320dpi)
Optional (screen size):
 4.7" diagonal

• Cobalah untuk mendapatkan semua nilai piksel dalam angka genap dari tim kreatif. Kalau tidak, kehilangan presisi akan terjadi saat mengalikan dengan 0,5.

px

Dijelaskan di atas. Coba hindari dalam file tata letak. Tetapi ada beberapa kasus, di mana px diperlukan. misalnya, garis pembagi ListView. px lebih baik di sini untuk memberikan garis satu-pixel sebagai pembagi untuk semua resolusi layar.

sp

Gunakan sp untuk ukuran font. Maka hanya font di dalam aplikasi yang akan berubah sementara ukuran font perangkat berubah (yaitu, Tampilan -> Font pada Perangkat). Jika Anda ingin menyimpan font berukuran statis di dalam aplikasi, Anda dapat memberikan dimensi font dalam dp. Dalam kasus seperti itu, itu tidak akan pernah berubah. Pengembang mungkin mendapatkan persyaratan seperti itu untuk beberapa layar tertentu, untuk itu, pengembang dapat menggunakan dp bukan sp. Dalam semua kasus lain, sp direkomendasikan.

Anda dapat melihat perbedaan antara pxdan dpdari gambar di bawah ini, dan Anda juga dapat menemukan bahwa pxdan dptidak dapat menjamin ukuran fisik yang sama pada layar yang berbeda.

Apa pun yang terkait dengan ukuran teks dan tampilan harus menggunakan spatau pt. Padahal, apa pun yang terkait dengan ukuran kontrol, tata letak, dll. Harus digunakan dp.

Anda dapat menggunakan keduanya dpdan dipdi tempatnya.

Saya hanya akan menggunakan dp.

Ada banyak pembicaraan tentang menggunakan "sp" untuk ukuran font, dan sementara saya menghargai intinya, saya tidak berpikir itu adalah hal yang benar untuk dilakukan dari sudut pandang desain. Anda akhirnya dapat merusak desain Anda jika pengguna memiliki beberapa pilihan ukuran font miring, dan pengguna akhirnya akan menyalahkan aplikasi , dan bukan pilihan hidup mereka sendiri.

Juga, jika Anda mengambil aplikasi font-sp pada tablet 160 dpi, Anda akan menemukan bahwa semuanya meningkat ... tetapi font Anda, yang akan terlihat kecil jika dibandingkan. Itu bukan tampilan yang bagus.

Meskipun gagasan font "sp" memiliki hati yang baik, itu adalah ide yang buruk. Tetap dengan dp untuk semuanya.

sp = skala piksel independen

dp = dip = kerapatan piksel independen

dpi = titik per inci

Kita harus menghindari penggunaan sp .

Kita harus menggunakan dp untuk mendukung banyak layar.

Android mendukung resolusi layar yang berbeda

• ldpi (rendah) ~ 120 dpi
• mdpi (sedang) ~ 160 dpi
• hdpi (tinggi) ~ 240 dpi
• xhdpi (ekstra tinggi) ~ 320 dpi
• xxhdpi (ekstra-ekstra-tinggi) ~ 480 dpi
• xxxhdpi (ekstra-ekstra-ekstra-tinggi) ~ 640 dpi

Perangkat 120 dp ldpi memiliki 120 piksel dalam ukuran 1 inci.

Hal yang sama untuk kepadatan lainnya ...

Kami sebagai insinyur perangkat lunak harus menggunakan rumus konversi ini:

pixel = dp * (kepadatan / 160)

Jadi 240 dpi perangkat 1 dp akan memiliki = 1 * (240/160) = 3/2 = 1,5 piksel.

Dan 480 dpi perangkat 1 dp akan memiliki = 1 * (480/160) = 3 piksel.

Menggunakan pengetahuan 1,5 dan 3 piksel ini, seorang insinyur perangkat lunak dapat merancang tata letak untuk kepadatan yang berbeda.

Untuk memeriksa parameter layar perangkat apa pun:

DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);

Toast.makeText(
    this,
    "4:" + metrics.heightPixels + "," + metrics.density + ","
    + metrics.densityDpi, Toast.LENGTH_LONG).show();

Perbedaan antara dpdan spunit yang disebut sebagai " preferensi ukuran font pengguna " oleh jawaban yang disalin dari dokumentasi resmi dapat dilihat pada waktu berjalan dengan mengubah Settings->Accessibility->Large Textopsi.

Large Textopsi memaksa teks menjadi 1.3lebih besar kali.

private static final float LARGE_FONT_SCALE = 1.3f;

Ini tentu saja tergantung pada vendor karena terletak pada paket / aplikasi / Pengaturan .

dpi -

• Titik per inci
• Mengukur kerapatan piksel layar.

px - pixel

• Untuk memetakan piksel layar

pt - poin

• Sekitar 1/72 inci, berkenaan dengan ukuran layar fisik.

in - inch - sehubungan dengan ukuran layar fisik (1 inch = 2.54 cm).

mm- milimeter - sehubungan dengan ukuran layar fisik.

sp - skala-pixel independen.

• Berdasarkan preferensi ukuran font pengguna.
• Font harus dalam 'sp'.

celupkan -

• celupkan == dp
• Pixel independen kepadatan.
• Ini bervariasi berdasarkan Kepadatan Layar.
• Dalam layar 160 dpi, 1 dp = 1 piksel.
• Gunakan dp kecuali ukuran font teks.

Secara standar, dp dan sp digunakan. sp untuk ukuran font dan dp untuk yang lainnya.

Formula untuk konversi unit:

px = dp * (dpi / 160);

Density Bucket -> Screen Display => Physical Size        => Pixel Size                   

ldpi         -> 120 dpi          => 0.5 x 0.5 in         => 0.5 in * 120 dpi = 60x60 px   

mdpi         -> 160 dpi          => 0.5 x 0.5 in         => 0.5 in * 160 dpi = 80x80 px   

hdpi         -> 240 dpi          => 0.5 x 0.5 in         => 0.5 in * 240 dpi = 120x120 px  

xhdpi        -> 320 dpi          => 0.5 x 0.5 in         => 0.5 in * 320 dpi = 160x160 px  

xxhdpi       -> 480 dpi          => 0.5 x 0.5 in         => 0.5 in * 480 dpi = 240x240 px 

xxxhdpi      -> 640 dpi          => 0.5 x 0.5 in         => 0.5 in * 640 dpi = 320x320 px  

Berikut rumus yang digunakan oleh Android:

px = dp * (dpi / 160)

Di mana dpi adalah salah satu dari kepadatan layar berikut. Untuk daftar semua kepadatan yang memungkinkan buka di sini

Ini mendefinisikan konstanta "DENSITY_ *".

• ldpi (rendah) ~ 120dpi
• mdpi (sedang) ~ 160dpi
• hdpi (tinggi) ~ 240dpi
• xhdpi (ekstra tinggi) ~ 320dpi
• xxhdpi (ekstra-tinggi-tinggi) ~ 480dpi
• xxxhdpi (ekstra-ekstra-ekstra-tinggi) ~ 640dpi

Diambil dari sini .

Ini akan memilah banyak kebingungan ketika menerjemahkan antara px dan dp, jika Anda tahu dpi layar Anda.

Jadi, katakanlah Anda menginginkan gambar 60 dp untuk layar hdpi maka ukuran piksel fisik 60 dp adalah:

px = 60 * (240 / 160)

Ukuran Layar di Androiddikelompokkan ke dalam kategori small, medium, large, extra large, double-extradan triple-extra. Kepadatan layar adalah jumlah piksel dalam area (seperti inci) layar. Biasanya diukur dalam titik-per-inci (dpi). Kepadatan layar dikelompokkan sebagai rendah, sedang, tinggi dan ekstra tinggi. Resolusi adalah jumlah total piksel di layar.

• dp: Density Independent Pixel, ini bervariasi berdasarkan kepadatan layar. Dalam layar 160 dpi, 1 dp = 1 piksel. Kecuali untuk ukuran font, gunakan dp selalu.
• menukik: dip == dp. Pada versi Android sebelumnya, dip digunakan dan kemudian diubah menjadi dp.
• sp: Scale Independent Pixel, diskalakan berdasarkan preferensi ukuran font pengguna. Font harus menggunakan sp.
• px: piksel standar kami yang biasa yang memetakan ke piksel layar.
• dalam: inci, sehubungan dengan ukuran layar fisik.
• mm: milimeter, sehubungan dengan ukuran layar fisik.
• pt: 1/72 inci, sehubungan dengan ukuran layar fisik.

Formula untuk Konversi antar Unit

 px = dp * (dpi / 160)

dp ke px di perangkat

Contoh berikut dapat membantu memahami dengan lebih baik. Penskalaan terjadi berdasarkan ukuran bucket 120 (ldpi), 160 (mdpi), 240 (hdpi), 320 (xhdpi), 480 (xxhdpi) dan 640 (xxxhdpi). Rasio yang disarankan Google untuk merancang adalah 3: 4: 6: 8: 12 untuk ldpi: mdpi: hdpi: xhdpi: xxhdpi

Gambar 150px X 150px akan menempati,

• 150 dp X 150 dp ruang layar dalam mdpi
• 100 dp X 100 dp ruang layar dalam hdpi
• 75 dp X 75 dp ruang layar dalam xhdpi

Anda dapat menggunakan kalkulator DPI berikut untuk memperbaiki ukuran gambar dan dimensi lain saat Anda ingin memiliki desain UI yang seragam di semua perangkat Android.

Kalkulator DPI di Jawa

/*
Program output
LDPI: 165.0 X 60.0
MDPI: 220.0 X 80.0
HDPI: 330.0 X 120.0
XHDPI: 440.0 X 160.0
XXHDPI: 660.0 X 240.0
XXXHDPI: 880.0 X 320.0
*/


public class DPICalculator {

private final float LDPI = 120;
private final float MDPI = 160;
private final float HDPI = 240;
private final float XHDPI = 320;
private final float XXHDPI = 480;
private final float XXXHDPI = 640;    

private float forDeviceDensity;
private float width;
private float height;

public DPICalculator(float forDeviceDensity, float width, float height){
    this.forDeviceDensity = forDeviceDensity;
    this.width = width;
    this.height = height;
}

public static void main(String... args) {
    DPICalculator dpiCalculator = new DPICalculator(240,330,120);
    dpiCalculator.calculateDPI();
}


private float getPx(float dp, float value) {
    float px = dp * (value / forDeviceDensity );        
    return px;
}

private void calculateDPI() {

    float ldpiW = getPx(LDPI,width);        
    float ldpiH =  getPx(LDPI,height);
    float mdpiW = getPx(MDPI,width);        
    float mdpiH =  getPx(MDPI,height);        
    float hdpiW = getPx(HDPI,width);        
    float hdpiH =  getPx(HDPI,height);       
    float xdpiW = getPx(XHDPI,width);        
    float xdpiH =  getPx(XHDPI,height);
    float xxdpiW = getPx(XXHDPI,width);        
    float xxdpiH =  getPx(XXHDPI,height);
    float xxxdpiW = getPx(XXXHDPI,width);        
    float xxxdpiH =  getPx(XXXHDPI,height);

    System.out.println("LDPI: " + ldpiW + " X " + ldpiH);
    System.out.println("MDPI: " + mdpiW + " X " + mdpiH);
    System.out.println("HDPI: " + hdpiW + " X " + hdpiH);
    System.out.println("XHDPI: " + xdpiW + " X " + xdpiH);
    System.out.println("XXHDPI: " + xxdpiW + " X " + xxdpiH);
    System.out.println("XXXHDPI: " + xxxdpiW + " X " + xxxdpiH);        
   }
}

Informasi Lebih Lanjut merujuk tautan berikut.

http://javapapers.com/android/difference-between-dp-dip-sp-px-in-mm-pt-in-android/

Silakan baca jawabannya dari wiki komunitas. Di bawah ini disebutkan beberapa informasi yang harus dipertimbangkan selain jawaban di atas. Sebagian besar pengembang Android melewatkan ini saat mengembangkan aplikasi, jadi saya menambahkan poin ini.

sp = skala piksel independen

dp = piksel independen kepadatan

dpi = kerapatan piksel

Saya telah melalui jawaban di atas ... tidak menemukan jawaban yang benar. sp untuk ukuran teks, dp untuk batas tata letak - standar. Tetapi sp untuk ukuran teks akan merusak tata letak jika digunakan secara sembarangan di sebagian besar perangkat.

sp mengambil ukuran teks perangkat, sedangkan dp mengambil standar kepadatan perangkat (tidak pernah berubah dalam perangkat) Katakanlah teks 100sp dapat menempati 80% layar atau 100% layar tergantung pada ukuran font yang ditetapkan dalam perangkat

Anda dapat menggunakan sp untuk batas tata letak juga, itu akan berfungsi :) Tidak ada aplikasi standar menggunakan sp untuk seluruh teks

Gunakan sp dan dp untuk ukuran teks mempertimbangkan UX.

• Jangan gunakan sp untuk teks dalam bilah alat (dapat menggunakan dimens android yang tersedia untuk ukuran layar berbeda dengan dp)
• Jangan gunakan sp untuk teks dalam tombol terbatas kecil, teks sangat kecil, dll

Beberapa orang menggunakan ukuran FONT yang besar di telepon mereka untuk lebih mudah dibaca, memberi mereka teks berukuran kecil yang dikode akan menjadi masalah UX. Letakkan sp untuk teks jika perlu, tetapi pastikan tidak akan merusak tata letak ketika pengguna mengubah pengaturannya.

Demikian pula jika Anda memiliki aplikasi tunggal yang mendukung semua dimensi, menambahkan aset xxxhdpi meningkatkan ukuran aplikasi banyak. Tapi sekarang ponsel xxxhdpi sudah umum jadi kami harus memasukkan aset xxxhdpi minimal untuk ikon di bilah samping, bilah alat, dan bilah bawah. Lebih baik pindah ke gambar vektor untuk memiliki gambar yang seragam dan berkualitas lebih baik untuk semua ukuran layar.

Perhatikan juga bahwa orang menggunakan font khusus di telepon mereka. Jadi kekurangan font dapat menyebabkan masalah terkait spasi dan semua. Katakanlah ukuran teks 12sp untuk font khusus mungkin memerlukan beberapa piksel lebih dari font default.

Referensikan situs pengembang google untuk detail screendensity dan basedensity untuk android. https://developer.android.com/training/multiscreen/screendensities

• px - satu piksel, sama dengan apa yang digunakan dalam CSS, JavaScript, dll.
• sp - skala-piksel independen
• dip - piksel independen-kepadatan

Biasanya sp digunakan untuk ukuran font, sementara dip digunakan (juga disebut dp) untuk yang lain.

Saya telah menemukan artikel yang bagus tentang merancang UI aplikasi Android untuk resolusi layar yang berbeda, dan saya ingin meninggalkannya di sini hanya untuk seseorang yang mencari di area ini. Ya, saya tahu itu dijelaskan dalam Google docs (dan disebutkan dalam posting di atas), saya membacanya tetapi itu tidak baik untuk saya (ya, saya mungkin terlalu bodoh)). Masih belum jelas bagi saya bagaimana merancang tata letak yang mampu menangani ukuran layar yang berbeda. Saya benci konsep DP dan sebagainya, ketika saya perlu menerapkan tata letak UI "fleksibel" untuk layar yang berbeda. (Hai pengembang iOS - ya, Anda benar itu adalah konsep Storyboard).

Android tidak memiliki konsep UI yang buruk, tetapi tidak memiliki fitur iOS Storyboard. Merancang UI fleksibel di Android bukanlah hal yang mudah (yang terbaik).

Ini dia artikel yang membantu saya memahami apa yang harus dilakukan di Android untuk membuat layout untuk berbagai ukuran layar:

JMSTUDIO Blog: - Tentukan Ukuran Layar Aplikasi Android

Bagaimana Mendesain UI untuk Aplikasi Android untuk Ukuran Layar yang Berbeda

Untuk merancang UI aplikasi untuk ukuran layar yang berbeda, desain awal kami harus memenuhi ruang minimum yang diperlukan untuk setiap ukuran layar. Android menetapkan ukuran minimum (dalam dp) untuk setiap jenis layar umum. Berikut adalah pedoman ukuran layar Android. Ketika kami mendapatkan ukuran layar dalam dp, tidak cukup bagi kami untuk mendesain UI aplikasi Android. Untuk setiap ukuran layar, kita perlu menyiapkan grafik dan gambar bitmap untuk setiap kepadatan. Berikut adalah pedoman kepadatan layar Android.

Untuk perhitungan yang mudah, kita dapat mengikuti rasio penskalaan 3: 4: 6: 8 antara empat kepadatan umum. Jika kita membuat gambar 36x36 piksel untuk perangkat ldpi, ukuran gambar kepadatan lainnya akan menjadi 48 × 48 untuk mdpi, 72 × 72 untuk hdpi, dan 96 × 96 untuk xhdpi.

Cara Mendesain Aplikasi Android UI di Photoshop

Banyak desainer memiliki masalah untuk merancang UI aplikasi Android di photoshop atau alat desain grafis berbasis pixel lainnya karena unit yang tidak tergantung kepadatan, dp. Desainer tidak tahu cara memetakan dp ke piksel. Google juga tidak memberikan panduan desain UI Android yang jelas untuk mereka, meskipun mereka memberikan formula dasar untuk terjemahan dp dan piksel.

Seperti definisi Android, 1pd sama dengan 1px di bawah perangkat 160 dpi (mdpi). Jadi kami ingin merancang aplikasi Android untuk perangkat Android xlarge dengan kepadatan mdpi, kami dapat menentukan ukuran UI kami dalam piksel sebagai lebar 960 piksel dan tinggi 720px; Ikuti aturan pemetaan yang sama, kita bisa mengikuti pedoman desain UI ukuran layar Android App:

TAMBAH : Jika Anda tertarik pada UI "fleksibel" juga, lihat perpustakaan ini: Android SDK yang menyediakan unit ukuran baru - sdp (scpable dp). Unit ukuran ini berskala dengan ukuran layar (ini juga disebutkan dalam jawaban di sini, tentang SDPperpustakaan)

ADDED2 Google akhirnya memahami kegunaan konsep iOS Storeboard UI, dan inilah ConstraintLayoutdunia Android: Bangun UI Responsif dengan ConstraintLayout

1) dp: (density independent pixels)

Jumlah piksel yang diwakili dalam satu unit dp akan meningkat seiring resolusi layar meningkat (ketika Anda memiliki lebih banyak titik / piksel per inci). Sebaliknya pada perangkat dengan resolusi lebih rendah, jumlah piksel yang diwakili dalam satuan dp akan berkurang. Karena ini adalah unit relatif, perlu memiliki garis dasar untuk dibandingkan dengan. Garis dasar ini adalah layar 160 dpi. Inilah persamaannya:px = dp * (dpi / 160).

2) sp: (scale independent pixels)

Unit ini berskala sesuai dengan dpi layar (mirip dengan dp) serta preferensi ukuran font pengguna.

3) px: (pixels)

Pixel atau titik aktual di layar.

Untuk detail lebih lanjut, Anda dapat mengunjungi

Panduan Pengembang Android> Dimensi
Panduan Pengembang Android> Layar

Ukuran layar di Android dikelompokkan ke dalam kategori ldpi, mdpi, hdpi, xhdpi, xxhdpidan xxxhdpi. Kepadatan layar adalah jumlah piksel dalam area (seperti inci) layar. Umumnya diukur dalam titik-per-inci ( dpi).

PX(Pixels):

• pixel standar biasa kami yang memetakan ke pixel layar. pxdimaksudkan untuk piksel absolut. Ini digunakan jika Anda ingin memberikan piksel absolut untuk lebar atau tinggi. Tidak direkomendasikan.

DP/DIP(Density pixels / Density independent pixels):

• dip == dp. Dalam versi Android sebelumnya dip digunakan dan kemudian diubah menjadi dp. Ini adalah alternatif px.

• Secara umum kami tidak pernah menggunakan pxkarena itu adalah nilai absolut. Jika Anda menggunakan pxuntuk mengatur lebar atau tinggi, dan jika aplikasi itu sedang diunduh ke perangkat berukuran layar yang berbeda, maka tampilan itu tidak akan melebar sesuai dengan ukuran asli layar.

• dpsangat disarankan untuk digunakan sebagai pengganti px. Gunakan dpjika Anda ingin menyebutkan lebar dan tinggi untuk tumbuh & menyusut secara dinamis berdasarkan ukuran layar.

• jika kita berikan dp/dip, android akan secara otomatis menghitung ukuran piksel berdasarkan layar berukuran 160 piksel.

SP(Scale independent pixels):

• diskalakan berdasarkan preferensi ukuran font pengguna. Font harus digunakan sp.

• ketika menyebutkan ukuran font yang cocok untuk berbagai ukuran layar, gunakan sp. Ini mirip dengan dp.Gunakansp terutama untuk ukuran font yang tumbuh & menyusut secara dinamis berdasarkan ukuran layar

Dokumentasi Android mengatakan:

saat menentukan dimensi, selalu gunakan satuan dpatau spsatuan. A dpadalah piksel yang tidak tergantung kepadatan yang sesuai dengan ukuran fisik piksel pada 160 dpi. An spadalah unit dasar yang sama, tetapi diskalakan oleh ukuran teks pilihan pengguna (ini adalah pixel skala-independen), jadi Anda harus menggunakan unit pengukuran ini saat menentukan ukuran teks

Layar ponsel terdiri dari ribuan titik kecil yang dikenal sebagai piksel (px) . Piksel adalah elemen terkecil yang digunakan untuk membuat gambar. Semakin banyak jumlah piksel untuk membuat gambar atau kata-kata, semakin tajam jadinya dan membuat layar smartphone lebih mudah dibaca.

Resolusi layar diukur dari jumlah piksel pada layar. Resolusi layar adalah spesifikasi yang umum digunakan ketika membeli perangkat, tetapi sebenarnya tidak berguna ketika mendesain untuk Android karena berpikir layar dalam hal piksel mengabaikan gagasan tentang ukuran fisik, yang untuk perangkat sentuh benar-benar sangat penting.

Piksel independen kepadatan (dp atau celup) memungkinkan perancang untuk membuat aset yang muncul dengan cara yang diharapkan, tidak peduli resolusi atau kepadatan perangkat target.

Pixel independent density (dp atau dip) sama dengan satu pixel pada density baseline atau 160 dpi (dots per inch).

1 px / 1dp = 160 dpi / 160 dpi

2 px / 1dp = 320 dpi (2x) / 160 dpi

dimana,

dpi adalah titik per inci

Jadi, pada 320 dpi, 1 dp sama dengan 2 px.

Rumus

px / dp = dpi / 160dpi

Dots per inch (dpi) adalah ukuran ketajaman (yaitu, kepadatan titik-titik yang menyala) pada layar tampilan. Titik-titik per inci untuk resolusi gambar yang diberikan akan berbeda berdasarkan ukuran layar keseluruhan karena jumlah piksel yang sama tersebar di ruang yang berbeda.

Bekerja dengan piksel bebas kepadatan membantu kami menghadapi situasi seperti di mana Anda memiliki dua perangkat dengan resolusi piksel yang sama, tetapi jumlah ruang yang berbeda. Misalkan dalam sebuah kasus, tablet dan ponsel memiliki resolusi piksel yang sama, masing-masing 1280 kali 800 piksel (160 dpi) dan 800 x 1280 piksel (320 dpi).

Sekarang karena tablet berada pada kepadatan awal (160 dpi), ukuran piksel independen fisik dan kepadatannya sama, 1280 x 800. Ponsel di sisi lain memiliki kerapatan piksel lebih tinggi, sehingga memiliki kepadatan piksel independen setengah lebih banyak daripada fisik. piksel. Jadi ponsel memiliki 400 x 640 kepadatan piksel independen. Jadi menggunakan pixel yang tidak tergantung kepadatan membuatnya lebih mudah untuk menggambarkan secara mental bahwa tablet memiliki lebih banyak ruang daripada ponsel.

Demikian pula, jika Anda memiliki dua perangkat dengan ukuran layar yang sama, tetapi kerapatan piksel yang berbeda, katakanlah satu adalah 800 x 1280 piksel (320 dpi), dan yang lain adalah 400 x 640 piksel (160 dpi), kita tidak perlu mendefinisikan secara total tata letak yang berbeda untuk kedua perangkat ini karena kami dapat mengukur aset dalam hal kepadatan pixel independen yang sama untuk kedua perangkat.

800 x 1280 piksel (320dpi) = 400 x 640 kepadatan, piksel bebas (dp)

400 x 640 piksel (160 dpi) = 400 x 640 piksel independen (dp)

Skala piksel independen (sp) adalah unit yang disukai untuk ukuran font. Untuk tujuan aksesibilitas, Android memungkinkan pengguna untuk menyesuaikan ukuran font perangkat mereka. Pengguna yang mengalami kesulitan membaca teks dapat meningkatkan ukuran font perangkat mereka. Anda biasanya dapat menemukan opsi ini di pengaturan tampilan di ponsel atau tablet Anda di bawah ukuran font. Ini sering juga tersedia melalui pengaturan aksesibilitas.

Dengan skala piksel independen, 16 sp persis sama dengan 16 dp ketika ukuran font perangkat normal atau 100%. Tetapi ketika ukuran font perangkat besar, misalnya 125%, 16 sp akan diterjemahkan menjadi 20 dp atau 1,25 kali 16.

Jika Anda menggunakan dp sebagai satuan untuk ukuran font, maka bagian teks itu memiliki ukuran fisik tertentu, tidak peduli apakah pengguna telah menyesuaikan ukuran font perangkat. Menggunakan unit sp akan membuat pengalaman yang lebih baik bagi orang dengan gangguan penglihatan.

Referensi : Udacity , Google

sp: skala piksel independen

Anda harus menggunakannya dengan teks karena secara otomatis diskalakan sesuai dengan ukuran font yang digunakan oleh pengguna di perangkatnya.

px: piksel atau elemen gambar adalah satu-satunya titik di layar

Kerapatan piksel

Kerapatan dan resolusi piksel layar bervariasi tergantung pada platform. Pixel yang tidak tergantung pada perangkat dan piksel yang dapat diskalakan adalah unit yang menyediakan cara yang fleksibel untuk mengakomodasi desain lintas platform.

Menghitung kerapatan piksel

Jumlah piksel yang masuk dalam satu inci disebut sebagai kerapatan piksel. Layar kepadatan tinggi memiliki lebih banyak piksel per inci daripada yang ...

Jumlah piksel yang masuk dalam satu inci disebut sebagai kerapatan piksel. Layar kepadatan tinggi memiliki lebih banyak piksel per inci daripada yang kepadatan rendah. Akibatnya, elemen UI dengan dimensi piksel yang sama tampak lebih besar pada layar kepadatan rendah, dan lebih kecil pada layar kepadatan tinggi.

Untuk menghitung kepadatan layar, Anda dapat menggunakan persamaan ini:

Kerapatan layar = Lebar layar (atau tinggi) dalam piksel / Lebar layar (atau tinggi) dalam inci

Kemandirian kepadatan

Kerapatan dan resolusi piksel layar bervariasi tergantung pada platform. Pixel yang tidak tergantung pada perangkat dan piksel yang dapat diskalakan adalah unit yang menyediakan cara yang fleksibel untuk mengakomodasi desain lintas platform.

Menghitung kerapatan piksel Jumlah piksel yang masuk ke dalam inci disebut sebagai kerapatan piksel . Layar kepadatan tinggi memiliki lebih banyak piksel per inci daripada yang ...

Independensi kepadatan mengacu pada tampilan seragam elemen UI pada layar dengan kepadatan berbeda.

Pixel-independent pixel , ditulis sebagai dp (dilafalkan " dips "), adalah unit fleksibel yang skala untuk memiliki dimensi seragam pada layar apa pun. UI Bahan menggunakan piksel yang tidak tergantung kerapatan untuk menampilkan elemen secara konsisten pada layar dengan kerapatan berbeda.

1. Layar kepadatan rendah ditampilkan dengan independensi kepadatan
2. Layar kepadatan tinggi ditampilkan dengan independensi kepadatan

Baca teks lengkap https://material.io/design/layout/pixel-density.html

Piksel (px) - sesuai dengan piksel aktual di layar. Ini digunakan jika Anda ingin memberikan piksel absolut untuk lebar atau tinggi.

Pixel-independent Pixels (dp atau dip) - unit abstrak yang didasarkan pada kepadatan fisik layar. Unit-unit ini relatif terhadap layar 160 dpi, jadi satu dp adalah satu piksel pada layar 160 dpi. Rasio dp-ke-pixel akan berubah dengan kerapatan layar, tetapi tidak harus dalam proporsi langsung. Catatan: Compiler menerima "dip" dan "dp", meskipun "dp" lebih konsisten dengan "sp".

Skala-independen Pixels (sp) - ini seperti unit dp, tetapi juga diskalakan oleh preferensi ukuran font pengguna. Disarankan Anda menggunakan unit ini saat menentukan ukuran font, sehingga mereka akan disesuaikan untuk kepadatan layar dan preferensi pengguna.

Selalu gunakan hanya dp dan sp. sp untuk ukuran font dan dp untuk yang lainnya. Ini akan membuat UI kompatibel untuk perangkat Android dengan kepadatan berbeda. Anda dapat mempelajari lebih lanjut tentang piksel dan dp dari https://www.google.com/design/spec/layout/units-measurements.html#units-measurements-density-independent-pixels-dp-

Sumber url: - http://www.androidtutorialshub.com/what-is-the-difference-between-px-dp-dip-sp-on-android/

Saya ingin memberikan cara mudah untuk memahami dp. Bahkan, saya pikir dpadalah yang paling mudah untuk dipahami. dphanyalah satuan panjang fisik. Dimensi yang sama dengan mmatau inch. Lebih mudah bagi kita untuk menulis 50dp, 60dpdaripada 50/160 inchatau 60/160 inch, karena dphanya 1/160 inchukuran layar atau resolusinya saja.

Satu-satunya masalah adalah bahwa, dpi android dari beberapa layar tidak akurat. Misalnya, layar yang diklasifikasikan ke 160dpi mungkin memiliki 170dpi. Jadi hasil perhitungannya dpadalah fuzzy. Seharusnya kurang lebih sama dengan 1/160 inch.