Apa perbedaan antara Android satuan ukuran?
Dari Pengembang Android Dokumentasi:
px Piksel - sesuai dengan yang sebenarnya piksel pada layar.
dalam ** Inci** - berdasarkan ukuran fisik layar. 1 Inci = 2.54 cm
mm Milimeter - berdasarkan ukuran fisik layar.
pt Poin - 1/72 inch berdasarkan ukuran fisik layar.
dp atau dip Density-independen Piksel - unit abstrak yang didasarkan pada fisik kepadatan layar. Unit-unit ini adalah relatif terhadap 160 layar dpi, jadi satu dp adalah salah satu pixel pada 160 dpi layar. Rasio dp-untuk-pixel dengan kerapatan layar, tetapi belum tentu dalam proporsi langsung. Catatan: compiler menerima baik "dip" dan "dp", meskipun "dp" lebih konsisten dengan "s".
sp *Skala ***-independen Piksel - ini adalah dp unit, tetapi juga ditingkatkan oleh pengguna's ukuran font preferensi. Dianjurkan anda menggunakan unit ini ketika menentukan ukuran font, sehingga mereka akan disesuaikan baik untuk kepadatan layar dan pengguna's preferensi.
Dari Pemahaman Kepadatan Kemerdekaan Pada 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 juga ditemukan di Google Dokumentasi Desain.
Cukup banyak segala sesuatu tentang hal ini dan bagaimana untuk mencapai yang terbaik dukungan untuk beberapa layar dari berbagai ukuran dan kepadatan yang sangat baik didokumentasikan di sini:
ukuran Layar
Sebenarnya ukuran fisik, yang diukur sebagai layar's diagonal. Untuk kesederhanaan, Android memiliki semua sebenarnya ukuran layar menjadi empat generalized ukuran: kecil, normal, besar, ekstra besar.kerapatan Layar
jumlah piksel dalam area fisik screen; biasanya disebut sebagai dpi (dots per inch). Misalnya, "murah" kepadatan layar memiliki piksel lebih sedikit hanya diberikan fisik daerah, dibandingkan dengan "normal" atau "tinggi" kepadatan layar. Untuk kesederhanaan, Android memiliki semua sebenarnya kepadatan layar ke enam umum kepadatan: rendah, sedang, tinggi, ekstra tinggi, ekstra-ekstra-tinggi, dan ekstra-ekstra-ekstra-tinggi.Orientasi
orientasi layar dari pengguna's titik view. Ini adalah baik landscape atau portrait, yang berarti bahwa layar's rasio aspek baik lebar atau tinggi, masing-masing. Diketahui bahwa tidak hanya melakukan berbagai perangkat beroperasi dalam orientasi yang berbeda dengan default, tetapi orientasi dapat berubah pada saat runtime ketika pengguna berputar perangkat.
Resolusi
total jumlah piksel pada fisik layar. Ketika menambahkan dukungan untuk beberapa layar, aplikasi tidak bekerja secara langsung dengan resolusi; aplikasi harus peduli hanya dengan ukuran layar dan kepadatan, seperti yang ditentukan oleh umum ukuran dan kepadatan kelompok.
Kepadatan pixel-independen (dp)
virtual pixel unit yang harus anda gunakan ketika mendefinisikan tata letak UI, untuk mengekspresikan dimensi tata letak atau posisi dalam kepadatan-cara independen. kepadatan pixel-independen adalah setara dengan satu fisik pixel pada 160 layar dpi, yang merupakan dasar kepadatan diasumsikan oleh sistem untuk "sedang" kepadatan layar. Pada saat runtime, sistem transparan menangani scaling dp unit, seperti yang diperlukan, berdasarkan kepadatan yang sebenarnya layar yang di gunakan. Konversi dp unit untuk layar pixel sederhana:px = dp * (dpi / 160)
. misalnya, pada 240 dpi layar, 1 dp sama dengan 1.5 fisik piksel. Anda harus selalu menggunakan dp unit ketika mendefinisikan aplikasi anda's UI, untuk memastikan tampilan UI pada layar dengan kepadatan yang berbeda.
Jika anda serius tentang membangun sebuah aplikasi Android untuk lebih dari satu jenis perangkat, anda harus membaca layar mendukung pengembangan dokumen setidaknya sekali. Selain itu, itu selalu hal yang baik untuk mengetahui jumlah sebenarnya dari perangkat aktif yang memiliki layar konfigurasi.
Saya akan menjelaskan lebih lanjut tentang bagaimana tepatnya dp mengkonversi ke px:
150 x 150 px
gambar akan mengambil 150 * 150 dp
dari ruang layar.150 x 150 px
gambar akan mengambil 100 * 100 dp
dari ruang layar.150x150 px
gambar akan mengambil 75 * 75 dp
dari ruang layar.Cara lainnya: misalnya, anda ingin menambahkan gambar ke aplikasi anda dan anda perlu untuk mengisi 100 * 100 dp
kontrol. Anda'akan perlu untuk membuat ukuran yang berbeda gambar untuk didukung ukuran layar:
100 * 100 px
gambar untuk mdpi150 * 150 px
gambar untuk hdpi200 * 200 px
gambar untuk xhdpipx Piksel - point per skala sesuai dengan yang sebenarnya piksel pada layar.
di Inci - berdasarkan ukuran fisik layar.
mm Milimeter - berdasarkan ukuran fisik layar.
pt Poin - 1/72 inch berdasarkan ukuran fisik layar.
dp
Kepadatan - independen Piksel - unit abstrak yang didasarkan pada fisik kepadatan layar.
Unit-unit ini adalah relatif terhadap 160 dpi layar, jadi salah satu dp
adalah salah satu pixel pada 160 dpi layar. Rasio dp-untuk-pixel dengan kerapatan layar,
tetapi tidak harus dalam proporsi langsung.
Catatan: compiler menerima baik dip
dan dp
, meskipun dp
lebih konsisten dengan sp
.
sp
-Skala-independen Piksel - ini adalah seperti dp
unit,
tapi hal ini juga ditingkatkan oleh pengguna's ukuran font preferensi.
Dianjurkan bahwa anda menggunakan unit ini ketika menentukan ukuran font,
sehingga mereka akan disesuaikan untuk layar kepadatan dan pengguna's preferensi.
Ambil contoh dua layar yang memiliki ukuran yang sama tetapi memiliki kerapatan layar 160 dpi (titik per inci, yaitu pixel per inch) 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 berikut:
Ukuran layar:
Sebenarnya ukuran fisik, yang diukur sebagai layar's diagonal. Untuk kesederhanaan, Android memiliki semua sebenarnya ukuran layar menjadi empat generalized ukuran: kecil, normal, large, dan extra large.
Kerapatan layar:
jumlah piksel dalam fisik area layar; biasanya disebut sebagai dpi (dots per inch). Misalnya, "murah" kepadatan layar memiliki piksel lebih sedikit hanya diberikan fisik daerah, dibandingkan dengan "normal" atau "tinggi" kepadatan layar. Untuk kesederhanaan, Android memiliki semua sebenarnya kepadatan layar menjadi empat umum kepadatan: rendah, sedang, tinggi, dan ekstra tinggi.
Orientasi:
orientasi layar dari pengguna's point of view. Ini adalah baik landscape atau portrait, yang berarti bahwa layar's rasio aspek baik lebar atau tinggi, masing-masing. Diketahui yang tidak hanya melakukan berbagai perangkat beroperasi dalam orientasi yang berbeda secara default, tetapi orientasi dapat berubah pada saat runtime ketika pengguna berputar perangkat.
Resolusi:
total jumlah fisik piksel pada layar. Ketika menambahkan dukungan untuk beberapa layar, aplikasi tidak bekerja secara langsung dengan resolusi; aplikasi harus peduli dengan layar ukuran dan kepadatan, seperti yang ditentukan oleh umum ukuran dan kepadatan kelompok.
Kepadatan pixel-independen (dp):
virtual pixel unit yang harus anda gunakan ketika mendefinisikan tata letak UI, untuk menyatakan letak dimensi atau posisi di kepadatan-cara independen. Kepadatan pixel-independen adalah setara dengan satu fisik pixel pada 160 dpi layar, yang merupakan kepadatan dasar yang dipikul oleh sistem untuk "sedang" kepadatan layar. Pada saat runtime, sistem transparan menangani setiap skala dari dp unit, seperti yang diperlukan, berdasarkan pada kepadatan layar yang di gunakan. konversi dp unit untuk layar piksel sederhana: px = dp * (dpi / 160). Misalnya, pada 240 dpi layar, dp 1 sama dengan 1.5 fisik piksel. Anda harus selalu menggunakan dp unit ketika mendefinisikan anda aplikasi's UI, untuk memastikan tampilan UI pada layar dengan kepadatan yang berbeda.
Referensi: situs pengembang Android
dp
adalah dip
. Menggunakannya untuk segala sesuatu (margin, padding, dll.).
Gunakan sp
untuk {text-size} saja.
Melihat perbedaan antara px
, dp
dan sp
pada ukuran layar yang berbeda.
px atau dot adalah pixel pada layar fisik.
dpi adalah piksel per inci pada layar fisik dan mewakili kepadatan layar.
Android memberikan nama-nama alias untuk beberapa kepadatan
dip atau dp adalah kepadatan-indenpendant piksel, yaitu mereka sesuai dengan lebih atau kurang piksel tergantung pada kepadatan fisik.
sp atau sip adalah skala-independen pixel. Mereka yang ditingkatkan ketika Teks Besar pilihan diaktifkan di Pengaturan > Accessibility
Menggunakan sp untuk ukuran Teks.
Menggunakan dp untuk segala sesuatu yang lain.
Sumber 3: (data dari sumber 3 diberikan di bawah ini)
Ini adalah dimensi nilai-nilai yang didefinisikan dalam XML. Dimensi yang ditentukan dengan jumlah diikuti oleh satuan ukuran. Misalnya: 10px, 2in, 5sp. Berikut satuan ukuran yang didukung oleh Android:
dp
Density-independent Piksel - unit abstrak yang didasarkan pada fisik kepadatan layar. Unit-unit ini adalah relatif terhadap 160 dpi (dots per inch), yang 1dp adalah kira-kira sama untuk 1px. Ketika berjalan pada kepadatan yang lebih tinggi layar, jumlah piksel yang digunakan untuk menggambar 1dp lebih ditingkatkan dengan faktor yang sesuai untuk layar's dpi. demikian Juga, ketika pada kepadatan yang lebih rendah layar, jumlah piksel yang digunakan untuk 1dp diperkecil. Rasio dp-untuk-pixel akan berubah dengan kerapatan layar, tetapi tidak harus dalam proporsi langsung. Menggunakan dp unit (bukan px unit) adalah solusi yang sederhana untuk membuat tampilan yang dimensi dalam tata letak anda mengubah ukuran dengan benar untuk layar yang berbeda kepadatan. Dengan kata lain, ini memberikan konsistensi untuk dunia nyata ukuran elemen UI di perangkat yang berbeda.
sp
Skala-independen Piksel - Ini adalah dp unit, tetapi juga ditingkatkan oleh pengguna's ukuran font preferensi. Dianjurkan bahwa anda menggunakan unit ini ketika menentukan ukuran font, sehingga mereka akan disesuaikan untuk kedua kepadatan layar dan pengguna's preferensi.
pt
Poin - 1/72 inch berdasarkan ukuran fisik layar.
px
Piksel - Sesuai dengan yang sebenarnya piksel pada layar. Unit ini ukuran ini tidak dianjurkan karena sebenarnya representasi dapat bervariasi seluruh perangkat; setiap perangkat mungkin memiliki nomor yang berbeda dari piksel per inci dan mungkin memiliki lebih banyak atau lebih sedikit jumlah piksel yang tersedia di layar.
mm
Milimeter - Berdasarkan ukuran fisik layar.
dalam ****
Inci - Berdasarkan ukuran fisik layar.
Catatan: dimensi adalah sumber daya yang sederhana yang dirujuk dengan menggunakan nilai yang diberikan dalam nama atribut (bukan nama file XML). Dengan demikian, anda dapat menggabungkan dimensi sumber daya dengan sumber daya yang sederhana dalam satu file XML, di bawah satu
Pada dasarnya satu-satunya waktu di mana px berlaku adalah satu px, dan yang's jika anda ingin tepat satu pixel pada layar seperti dalam kasus pembagi:
Pada >160 dpi, anda mungkin mendapatkan 2-3 piksel,
Pada >120 dpi, itu putaran ke 0.
px
Piksel - sesuai dengan yang sebenarnya piksel pada layar.
dp atau dip
Density-independent Piksel - unit abstrak yang didasarkan pada fisik kepadatan layar. Unit-unit ini adalah relatif terhadap 160 dpi layar, jadi satu dp adalah salah satu pixel pada 160 dpi layar.
Gunakan dp:
Kepadatan kemerdekaan - Aplikasi anda mencapai "kepadatan kemerdekaan" ketika itu mempertahankan ukuran fisik (dari sudut pengguna pandang) dari elemen antarmuka pengguna ketika ditampilkan pada layar dengan kepadatan yang berbeda. (yaitu) gambar harus terlihat dengan ukuran yang sama (tidak membesar atau menyusut) dalam berbagai jenis layar.
sp
Skala-independen Piksel - ini adalah dp unit, tetapi juga ditingkatkan oleh pengguna's ukuran font preferensi.
http://developer.android.com/guide/topics/resources/more-resources.html#Dimension
Virtual pixel unit yang harus anda gunakan ketika mendefinisikan tata letak UI, untuk mengekspresikan dimensi tata letak atau posisi dalam kepadatan-cara independen. Seperti dijelaskan di atas, kepadatan pixel-independen adalah setara dengan satu fisik pixel pada 160 dpi layar, yang merupakan dasar kepadatan diasumsikan oleh sistem untuk "sedang" kepadatan layar. Pada saat runtime, sistem transparan menangani setiap skala dp unit, seperti yang diperlukan, berdasarkan pada kepadatan layar yang di gunakan. Konversi dp unit untuk layar pixel sederhana:
px = dp * (dpi / 160).
Misalnya, pada 240 dpi layar, dp 1 sama dengan 1.5 fisik piksel. Anda harus selalu menggunakan dp unit ketika mendefinisikan aplikasi anda's UI, untuk memastikan tampilan yang tepat dari UI pada layar dengan kepadatan yang berbeda.
Pengertian pixel untuk dp dan sebaliknya adalah sangat penting (terutama untuk memberikan tepat dp-nilai untuk 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
Hal ini telah dijelaskan di atas. Cobalah untuk menghindari tata letak file. Tapi ada beberapa kasus, di mana px diperlukan. misalnya, ListView pembagi line. px lebih baik di sini untuk memberikan satu-pixel line sebagai pembagi untuk semua resolusi layar.
Penggunaan sp untuk ukuran font. Maka hanya jenis huruf di dalam aplikasi akan berubah sementara perangkat font size perubahan (yaitu, Display -> Font pada Perangkat). Jika anda ingin menyimpan statis ukuran font dalam aplikasi, anda dapat memberikan jenis huruf dimensi di dp. Dalam kasus seperti itu, itu tidak akan pernah berubah. Pengembang dapat mendapatkan seperti kebutuhan untuk beberapa layar tertentu, untuk itu, pengembang dapat menggunakan dp bukannya sp. Dalam semua kasus lain, sp lebih direkomendasikan.
Apapun yang berhubungan dengan ukuran teks dan penampilan harus menggunakan sp
atau pt
. Padahal, apapun yang berhubungan dengan ukuran kontrol, layout, dll. harus digunakan dengan dp
.
Anda dapat menggunakan kedua dp
dan berenang
di tempat tersebut.
Saya hanya akan menggunakan dp.
Ada banyak berbicara tentang menggunakan "s" untuk ukuran font, dan sementara saya menghargai, saya don't berpikir bahwa itu adalah hal yang benar untuk dilakukan dari sudut pandang desain. Anda dapat berakhir melanggar desain anda jika pengguna memiliki beberapa wonky pemilihan ukuran font, dan pengguna akan berakhir menyalahkan aplikasi, dan bukan pilihan hidup mereka sendiri.
Juga, jika anda mengambil sp-font aplikasi pada 160 dpi tablet, anda akan menemukan bahwa segala sesuatu ** timbangan... tapi font anda, yang akan terlihat kecil dalam perbandingan. Ini isn't tampilan yang baik.
Sementara ide "s" font memiliki hati yang baik, itu adalah ide yang buruk. Tetap dengan dp untuk semuanya.
sp = skala independen pixel
dp = dip = kerapatan piksel independen
dpi = dot per inch
Kita harus menghindari untuk menggunakan sp.
Kita harus menggunakan dp dukungan untuk beberapa layar.
Android mendukung resolusi layar yang berbeda
Sebuah 120 dp ldpi device memiliki 120 piksel dalam 1 inci ukuran.
Sama lain kepadatan...
Kami sebagai insinyur perangkat lunak harus menggunakan konversi rumus:
pixel = dp * (density / 160)
Jadi 240 dpi perangkat's 1 dp akan memiliki = 1 * (240/160) = 3/2 = 1.5 piksel.
Dan 480 dpi perangkat's 1 dp akan memiliki = 1 * (480/160) = 3 piksel.
Menggunakan 1,5 dan 3 piksel pengetahuan, software engineer dapat merancang layout untuk kepadatan yang berbeda.
Untuk memeriksa layar parameter dari perangkat apapun:
DisplayMetrics metrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(metrics);
Toast.makeText(
this,
"4:" + metrics.heightPixels + "," + metrics.density + ","
+ metrics.densityDpi, Toast.LENGTH_LONG).show();
Perbedaan antara dp
dan sp
unit disebutkan sebagai "pengguna's ukuran font preferensi" dengan jawaban yang disalin dari dokumentasi resmi dapat dilihat pada waktu berjalan dengan mengubah Pengaturan->Accessibility->Teks Besar` pilihan.
Teks besar
pasukan pilihan teks untuk menjadi 1.3
kali lebih besar.
private static final float LARGE_FONT_SCALE = 1.3f;
Ini mungkin juga tentu saja tergantung vendor sejak itu terletak di paket/aplikasi/Pengaturan.
dpi -
px - pixel
pt - poin
di - inch
mm - milimeter
sp - skala-pixel independen.
dip -
Dalam standar, dp dan sp yang digunakan. sp untuk ukuran font dan dp untuk segala sesuatu yang lain.
Rumus 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
Ukuran layar di Android
dikelompokkan ke dalam kategori kecil
, medium
, besar
, ekstra besar
, double-tambahan
dan triple-ekstra
. Kepadatan layar adalah jumlah piksel dalam suatu daerah (seperti inci) layar. Umumnya diukur dengan dots per inch (dpi). Kepadatan layar dikelompokkan sebagai rendah, sedang, tinggi dan ekstra tinggi. Resolusi adalah jumlah pixel di layar.
Formula untuk Konversi antara Unit
px = dp * (dpi / 160)
dp untuk px di perangkat
Contoh berikut mungkin dapat membantu memahami lebih baik. Scaling terjadi berdasarkan pada ember ukuran 120(ldpi), 160(mdpi), 240(hdpi), 320(xhdpi), 480(xxhdpi) dan 640(xxxhdpi). Google menyarankan rasio untuk merancang adalah 3:4:6:8:12 untuk ldpi:mdpi:hdpi:xhdpi:xxhdpi
Sebuah 150px X 150px gambar yang akan menempati,
- 150 dp X 150 dp layar ruang pada perangkat mdpi
- 100 dp X 100 dp layar ruang di hdpi
- dp 75 X 75 dp layar ruang di xhdpi
Anda dapat menggunakan berikut DPI calculator untuk memperbaiki gambar anda ukuran dan dimensi lain ketika anda ingin memiliki seragam desain UI di semua perangkat Android.
/*
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 lihat link berikut.
http://javapapers.com/android/difference-between-dp-dip-sp-px-in-mm-pt-in-android/
Berikut's rumus yang digunakan oleh Android:
px = dp * (dpi / 160)
Di mana dpi adalah salah satu dari berikut ini kepadatan layar. Untuk daftar semua kemungkinan kepadatan masuk sini
Ini mendefinisikan "DENSITY_*" konstanta.
Diambil dari sini.
Ini akan memilah-milah banyak kebingungan ketika menerjemahkan antara px dan dp, jika anda tahu anda layar dpi.
Jadi, let's mengatakan anda ingin gambar dari 60 dp untuk hdpi layar maka fisik pixel ukuran 60 dp adalah:
px = 60 * (240 / 160)