หน่วยวัดของ Android แตกต่างกันอย่างไร

• px
• จุ่ม
• DP
• SP

จากเอกสารสำหรับนักพัฒนา Android :

1. px
   Pixels - สอดคล้องกับพิกเซลจริงบนหน้าจอ

2. ใน
   นิ้ว - ขึ้นอยู่กับขนาดทางกายภาพของหน้าจอ
   1 นิ้ว = 2.54 เซนติเมตร

3. มิลลิเมตร
   มิลลิเมตร - ขึ้นอยู่กับขนาดร่างกายของหน้าจอ

4. 
   คะแนนpt - 1/72 ของนิ้วขึ้นอยู่กับขนาดทางกายภาพของหน้าจอ

5. dpหรือจุ่ม
   ความหนาแน่น - พิกเซลอิสระ - หน่วยนามธรรมที่ขึ้นอยู่กับความหนาแน่นทางกายภาพของหน้าจอ หน่วยเหล่านี้สัมพันธ์กับหน้าจอ 160 dpi ดังนั้นหนึ่ง dp คือหนึ่งพิกเซลบนหน้าจอ 160 dpi อัตราส่วนของพิกเซลต่อพิกเซลจะเปลี่ยนตามความหนาแน่นของหน้าจอ แต่ไม่จำเป็นต้องเป็นสัดส่วนโดยตรง หมายเหตุ: คอมไพเลอร์ยอมรับทั้ง "dip" และ "dp" แม้ว่า "dp" จะสอดคล้องกับ "sp" มากขึ้น

6. sp
   Scale - พิกเซลอิสระ - นี่เหมือนกับหน่วย dp แต่ยังถูกปรับสัดส่วนตามขนาดตัวอักษรของผู้ใช้ ขอแนะนำให้คุณใช้หน่วยนี้เมื่อระบุขนาดตัวอักษรดังนั้นพวกเขาจะได้รับการปรับสำหรับทั้งความหนาแน่นของหน้าจอและความต้องการของผู้ใช้

จากการทำความเข้าใจความเป็นอิสระของความหนาแน่นใน 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      |               |             |                    | 
+---------+-------------+---------------+-------------+--------------------+

ข้อมูลเพิ่มเติมสามารถดูได้นอกจากนี้ยังพบได้ในเอกสาร Google ออกแบบ

ทุกอย่างเกี่ยวกับเรื่องนี้และวิธีการได้รับการสนับสนุนที่ดีที่สุดสำหรับหน้าจอหลายขนาดและความหนาแน่นต่างกันนั้นได้รับการบันทึกไว้ที่นี่:

• รองรับหลายหน้าจอ

ขนาดหน้าจอขนาด
ทางกายภาพจริงวัดเป็นเส้นทแยงมุมของหน้าจอ เพื่อความเรียบง่าย Android จะจัดกลุ่มขนาดหน้าจอจริงทั้งหมดเป็นขนาดทั่วไปสี่ขนาด: เล็กปกติใหญ่และใหญ่เป็นพิเศษ

ความหนาแน่นของหน้าจอ
จำนวนพิกเซลภายในพื้นที่ทางกายภาพของหน้าจอ มักเรียกว่า dpi (จุดต่อนิ้ว) ตัวอย่างเช่นหน้าจอความหนาแน่น "ต่ำ" มีพิกเซลน้อยลงภายในพื้นที่ทางกายภาพที่กำหนดเมื่อเปรียบเทียบกับหน้าจอความหนาแน่น "ปกติ" หรือ "สูง" สำหรับความเรียบง่าย Android จะจัดกลุ่มความหนาแน่นหน้าจอจริงทั้งหมดเป็นความหนาแน่นทั่วไปหกแบบ ได้แก่ ต่ำปานกลางสูงสูงพิเศษสูงพิเศษสูงพิเศษและสูงเป็นพิเศษ

การวางแนว
การวางแนวของหน้าจอจากมุมมองของผู้ใช้ นี่คือแนวนอนหรือแนวตั้งหมายความว่าอัตราส่วนหน้าจอกว้างหรือสูงตามลำดับ โปรดทราบว่าอุปกรณ์ต่าง ๆ ทำงานในทิศทางที่แตกต่างกันตามค่าเริ่มต้น แต่การวางแนวสามารถเปลี่ยนได้ในขณะทำงานเมื่อผู้ใช้หมุนอุปกรณ์

ความละเอียด
จำนวนพิกเซลทางกายภาพทั้งหมดบนหน้าจอ เมื่อเพิ่มการรองรับหลายหน้าจอแอปพลิเคชันจะไม่ทำงานโดยตรงกับความละเอียด แอปพลิเคชันควรเกี่ยวข้องกับขนาดและความหนาแน่นของหน้าจอตามที่ระบุโดยขนาดทั่วไปและกลุ่มความหนาแน่น

พิกเซลความหนาแน่นอิสระ (dp)
หน่วยพิกเซลเสมือนที่คุณควรใช้เมื่อกำหนดเค้าโครง UI เพื่อแสดงขนาดหรือตำแหน่งของเค้าโครงในแบบที่ไม่ขึ้นกับความหนาแน่น พิกเซลความหนาแน่นอิสระนั้นเทียบเท่ากับหนึ่งฟิสิคัลพิกเซลบนหน้าจอ 160 dpi ซึ่งเป็นความหนาแน่นพื้นฐานที่ระบบสันนิษฐานสำหรับหน้าจอความหนาแน่น "ปานกลาง" ณ รันไทม์ระบบจะจัดการกับการปรับขนาดของหน่วย dp ตามความจำเป็นโดยขึ้นอยู่กับความหนาแน่นที่แท้จริงของหน้าจอที่ใช้งานอยู่ การเปลี่ยนแปลงของหน่วย DP px = dp * (dpi / 160)พิกเซลหน้าจอเป็นเรื่องง่าย: ตัวอย่างเช่นบนหน้าจอ 240 dpi, 1 dp เท่ากับ 1.5 ฟิสิคัลพิกเซล คุณควรใช้หน่วย DP เมื่อกำหนด UI ของแอปพลิเคชันของคุณเพื่อให้แน่ใจว่าการแสดง UI ของคุณบนหน้าจอที่มีความหนาแน่นแตกต่างกัน

หากคุณจริงจังเกี่ยวกับการพัฒนาแอพ Android สำหรับอุปกรณ์มากกว่าหนึ่งประเภทคุณควรอ่านเอกสารสนับสนุนการพัฒนาหน้าจออย่างน้อยหนึ่งครั้ง นอกจากนั้นยังเป็นเรื่องดีที่จะทราบจำนวนอุปกรณ์ที่ใช้งานจริงที่มีการกำหนดค่าหน้าจอเฉพาะ

• ขนาดและความหนาแน่นของหน้าจอ

ฉันจะอธิบายเพิ่มเติมเกี่ยวกับวิธีการที่ dp แปลงเป็น px:

• หากทำงานบนอุปกรณ์ mdpi 150 x 150 pxภาพจะใช้150 * 150 dpพื้นที่หน้าจอมากขึ้น
• หากทำงานบนอุปกรณ์ hdpi 150 x 150 pxภาพจะใช้100 * 100 dpพื้นที่หน้าจอมากขึ้น
• หากทำงานบนอุปกรณ์ xhdpi 150x150 pxภาพจะใช้75 * 75 dpพื้นที่หน้าจอมากขึ้น

อีกวิธีหนึ่ง: พูดว่าคุณต้องการเพิ่มภาพลงในแอปพลิเคชันของคุณและคุณจำเป็นต้องใช้มันเพื่อเติมส่วน100 * 100 dpควบคุม คุณจะต้องสร้างภาพขนาดแตกต่างกันสำหรับขนาดหน้าจอที่รองรับ:

• 100 * 100 px รูปภาพสำหรับ mdpi
• 150 * 150 px รูปภาพสำหรับ hdpi
• 200 * 200 px รูปภาพสำหรับ xhdpi

px - พิกเซล - จุดต่อสเกลสอดคล้องกับพิกเซลจริงบนหน้าจอ

i - นิ้ว - ขึ้นอยู่กับขนาดทางกายภาพของหน้าจอ

mm - มิลลิเมตร - ขึ้นอยู่กับขนาดทางกายภาพของหน้าจอ

pt - คะแนน - 1/72 ของนิ้วขึ้นอยู่กับขนาดทางกายภาพของหน้าจอ

dp - พิกเซลที่ไม่มีความหนาแน่น - หน่วยนามธรรมที่ขึ้นอยู่กับความหนาแน่นทางกายภาพของหน้าจอ หน่วยเหล่านี้สัมพันธ์กับหน้าจอ 160 dpi ดังนั้นdpหนึ่งพิกเซลคือหนึ่งพิกเซลบนหน้าจอ 160 dpi อัตราส่วนของพิกเซลต่อพิกเซลจะเปลี่ยนตามความหนาแน่นของหน้าจอ แต่ไม่จำเป็นต้องเป็นสัดส่วนโดยตรง หมายเหตุ: คอมไพเลอร์ยอมรับทั้งในdipและdpแม้ว่าจะมีความสอดคล้องมากขึ้นด้วยdpsp

sp - พิกเซลที่dpปรับขนาดได้- นี่เป็นเหมือนหน่วย แต่จะถูกปรับสัดส่วนตามขนาดตัวอักษรของผู้ใช้ ขอแนะนำให้คุณใช้หน่วยนี้เมื่อระบุขนาดตัวอักษรดังนั้นพวกเขาจะถูกปรับสำหรับทั้งความหนาแน่นของหน้าจอและการตั้งค่าของผู้ใช้

นำตัวอย่างของหน้าจอสองหน้าจอที่มีขนาดเท่ากัน แต่หนึ่งหน้าจอมีความหนาแน่นหน้าจอ 160 dpi (จุดต่อนิ้วเช่นพิกเซลต่อนิ้ว) และอีกหน้าจอหนึ่งคือ 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

นอกจากนี้คุณควรมีความเข้าใจที่ชัดเจนเกี่ยวกับแนวคิดต่อไปนี้:

ขนาดหน้าจอ:

ขนาดจริงทางกายภาพวัดตามแนวทแยงมุมของหน้าจอ เพื่อความเรียบง่าย Android จะจัดกลุ่มขนาดหน้าจอจริงทั้งหมดเป็นขนาดทั่วไปสี่ขนาด: เล็กปกติใหญ่และใหญ่เป็นพิเศษ

ความหนาแน่นของหน้าจอ:

ปริมาณของพิกเซลภายในพื้นที่ทางกายภาพของหน้าจอ มักเรียกว่า dpi (จุดต่อนิ้ว) ตัวอย่างเช่นหน้าจอความหนาแน่น "ต่ำ" มีพิกเซลน้อยลงภายในพื้นที่ทางกายภาพที่กำหนดเมื่อเปรียบเทียบกับหน้าจอความหนาแน่น "ปกติ" หรือ "สูง" เพื่อความเรียบง่าย Android จะจัดกลุ่มความหนาแน่นของหน้าจอจริงทั้งหมดเป็นความหนาแน่นทั่วไปสี่แบบ ได้แก่ ต่ำปานกลางสูงและสูงพิเศษ

ปฐมนิเทศ:

การวางแนวของหน้าจอจากมุมมองของผู้ใช้ นี่คือแนวนอนหรือแนวตั้งหมายความว่าอัตราส่วนหน้าจอกว้างหรือสูงตามลำดับ โปรดทราบว่าอุปกรณ์ต่าง ๆ ทำงานในทิศทางที่แตกต่างกันตามค่าเริ่มต้น แต่การวางแนวสามารถเปลี่ยนได้ในขณะทำงานเมื่อผู้ใช้หมุนอุปกรณ์

ความละเอียด:

จำนวนพิกเซลทางกายภาพทั้งหมดบนหน้าจอ เมื่อเพิ่มการรองรับหลายหน้าจอแอปพลิเคชันจะไม่ทำงานโดยตรงกับความละเอียด แอปพลิเคชันควรเกี่ยวข้องกับขนาดและความหนาแน่นของหน้าจอตามที่ระบุโดยขนาดทั่วไปและกลุ่มความหนาแน่น

พิกเซลความหนาแน่นอิสระ (dp):

หน่วยพิกเซลเสมือนที่คุณควรใช้เมื่อกำหนดเค้าโครง UI เพื่อแสดงขนาดหรือตำแหน่งของเค้าโครงในลักษณะที่ไม่ขึ้นกับความหนาแน่น พิกเซลความหนาแน่นอิสระนั้นเทียบเท่ากับหนึ่งฟิสิคัลพิกเซลบนหน้าจอ 160 dpi ซึ่งเป็นความหนาแน่นพื้นฐานที่ระบบสันนิษฐานสำหรับหน้าจอความหนาแน่น "ปานกลาง" ณ รันไทม์ระบบจะจัดการกับการปรับขนาดของหน่วย dp ตามความจำเป็นโดยขึ้นอยู่กับความหนาแน่นที่แท้จริงของหน้าจอที่ใช้งานอยู่ การแปลงหน่วย dp เป็นพิกเซลหน้าจอนั้นง่าย: px = dp * (dpi / 160) ตัวอย่างเช่นบนหน้าจอ 240 dpi, 1 dp เท่ากับ 1.5 ฟิสิคัลพิกเซล คุณควรใช้หน่วย DP เมื่อกำหนด UI ของแอปพลิเคชันของคุณเพื่อให้แน่ใจว่าการแสดง UI ของคุณบนหน้าจอที่มีความหนาแน่นแตกต่างกัน

การอ้างอิง: เว็บไซต์นักพัฒนา Android

dpdipเป็น ใช้สำหรับทุกสิ่ง (ระยะขอบช่องว่างภายใน ฯลฯ )

ใช้spสำหรับ {text-size} เท่านั้น

เพื่อให้ได้ขนาดที่เท่ากันบนความหนาแน่นของหน้าจอที่แตกต่างกัน Android จะแปลงหน่วยเหล่านี้เป็นพิกเซลเมื่อใช้งานจริงดังนั้นจึงไม่มีคณิตศาสตร์ที่ยุ่งยากสำหรับคุณ

เห็นความแตกต่างระหว่างpx, dpและspในขนาดหน้าจอที่แตกต่างกัน

ที่มา: การเขียนโปรแกรม Android: The Big Nerd Ranch Guide

ผมได้คำนวณสูตรด้านล่างเพื่อให้การแปลงdpiไปdpและsp

คำนิยาม

pxหรือ dot เป็นพิกเซลบนหน้าจอแบบฟิสิคัล

dpiคือพิกเซลต่อนิ้วบนหน้าจอแบบฟิสิคัลและแสดงความหนาแน่นของจอแสดงผล

Android ให้ชื่อนามแฝงกับความหนาแน่นหลายระดับ

• ldpi (ต่ำ) ~ 120dpi
• mdpi (ปานกลาง) ~ 160dpi
• hdpi (สูง) ~ 240dpi
  • อุปกรณ์ส่วนใหญ่ในปี 2015 อยู่ที่นี่
• xhdpi (สูงเป็นพิเศษ) ~ 320dpi
  • Apple iPhone 4/5/6, Nexus 4
• xxhdpi (สูงเป็นพิเศษมาก) ~ 480dpi
  • Nexus 5
• xxxhdpi (สูงเป็นพิเศษมากเป็นพิเศษ) ~ 640dpi

จิ้มหรือdpคือพิกเซลความหนาแน่นอิสระซึ่งสอดคล้องกับพิกเซลมากหรือน้อยขึ้นอยู่กับความหนาแน่นทางกายภาพ

• 1dp = 1px สำหรับ mdpi

spหรือsipเป็นพิกเซลที่ปรับขนาดได้ สิ่งเหล่านี้จะถูกปรับขนาดเมื่อเปิดตัวเลือกข้อความขนาดใหญ่ในSettings>Accessibility

• 1sp = 1dp
• 1sp = 1.2dp พร้อมข้อความขนาดใหญ่สำหรับการเข้าถึง

จะใช้อะไรดี?

ใช้spสำหรับขนาดตัวอักษร

ใช้dpสำหรับทุกอย่าง

ที่มา 1

ที่มา 2

ที่มา 3 : (ข้อมูลจากแหล่งที่ 3 ระบุไว้ด้านล่าง)

นี่คือค่ามิติที่กำหนดไว้ใน XML มิติจะถูกระบุด้วยตัวเลขตามด้วยหน่วยการวัด ตัวอย่างเช่น: 10px, 2in, 5sp Android รองรับหน่วยการวัดต่อไปนี้:

DP

พิกเซลความหนาแน่นอิสระ - หน่วยนามธรรมที่ยึดตามความหนาแน่นทางกายภาพของหน้าจอ หน่วยเหล่านี้สัมพันธ์กับหน้าจอ 160 dpi (จุดต่อนิ้ว) ซึ่ง 1dp นั้นมีค่าประมาณ 1px เมื่อเรียกใช้บนหน้าจอที่มีความหนาแน่นสูงจำนวนพิกเซลที่ใช้ในการวาด 1dp จะถูกปรับสัดส่วนด้วยปัจจัยที่เหมาะสมสำหรับ dpi ของหน้าจอ ในทำนองเดียวกันเมื่อบนหน้าจอความหนาแน่นต่ำจำนวนพิกเซลที่ใช้สำหรับ 1dp จะถูกลดขนาดลง อัตราส่วนของพิกเซลต่อพิกเซลจะเปลี่ยนตามความหนาแน่นของหน้าจอ แต่ไม่จำเป็นต้องเป็นสัดส่วนโดยตรง การใช้หน่วย dp (แทนหน่วย px) เป็นวิธีง่ายๆในการทำให้ขนาดมุมมองในโครงร่างของคุณปรับขนาดอย่างถูกต้องสำหรับความหนาแน่นของหน้าจอที่แตกต่างกัน กล่าวอีกนัยหนึ่งมันให้ความสอดคล้องสำหรับขนาดจริงขององค์ประกอบ UI ของคุณในอุปกรณ์ต่าง ๆ

SP

พิกเซลที่ปรับขนาดได้ - เป็นเหมือนหน่วย dp แต่จะถูกปรับสัดส่วนตามขนาดตัวอักษรของผู้ใช้ ขอแนะนำให้คุณใช้หน่วยนี้เมื่อระบุขนาดตัวอักษรดังนั้นพวกเขาจะถูกปรับสำหรับทั้งความหนาแน่นของหน้าจอและการตั้งค่าของผู้ใช้

จุด

คะแนน - 1/72 ของนิ้วขึ้นอยู่กับขนาดทางกายภาพของหน้าจอ

px

พิกเซล - สอดคล้องกับพิกเซลจริงบนหน้าจอ ไม่แนะนำให้ใช้หน่วยวัดนี้เนื่องจากการแสดงจริงอาจแตกต่างกันไปตามอุปกรณ์ อุปกรณ์แต่ละชิ้นอาจมีจำนวนพิกเซลต่อนิ้วที่แตกต่างกันและอาจมีพิกเซลรวมมากกว่าหรือน้อยกว่าบนหน้าจอ

มิลลิเมตร

มิลลิเมตร - ขึ้นอยู่กับขนาดทางกายภาพของหน้าจอ

ใน

นิ้ว - ขึ้นอยู่กับขนาดทางกายภาพของหน้าจอ

หมายเหตุ:ส่วนข้อมูลเป็นทรัพยากรอย่างง่ายที่ถูกอ้างถึงโดยใช้ค่าที่ระบุในแอตทริบิวต์ name (ไม่ใช่ชื่อของไฟล์ XML) คุณสามารถรวมมิติข้อมูลเข้ากับทรัพยากรแบบง่ายอื่น ๆ ในไฟล์ XML ไฟล์เดียวภายใต้องค์ประกอบเดียว

โดยทั่วไปเวลาเดียวที่ px ใช้คือหนึ่ง px และนั่นคือถ้าคุณต้องการพิกเซลหนึ่งพิกเซลบนหน้าจอเหมือนกับในกรณีของตัวแบ่ง:

ใน> 160 dpi คุณอาจได้รับ 2-3 พิกเซล

ที่> 120 dpi, จะปัดเศษเป็น 0

px

พิกเซล - สอดคล้องกับพิกเซลจริงบนหน้าจอ

dp หรือจุ่ม

พิกเซลความหนาแน่นอิสระ - หน่วยนามธรรมที่ขึ้นอยู่กับความหนาแน่นทางกายภาพของหน้าจอ หน่วยเหล่านี้สัมพันธ์กับหน้าจอ 160 dpi ดังนั้นหนึ่ง dp คือหนึ่งพิกเซลบนหน้าจอ 160 dpi

การใช้ dp:

ความเป็นอิสระของความหนาแน่น - แอปพลิเคชันของคุณรับ“ ความเป็นอิสระของความหนาแน่น” เมื่อมันรักษาขนาดทางกายภาพ (จากมุมมองของผู้ใช้) ขององค์ประกอบส่วนต่อประสานผู้ใช้เมื่อแสดงบนหน้าจอที่มีความหนาแน่นต่างกัน (เช่น) ภาพควรมีขนาดเท่ากัน (ไม่ขยายหรือหด) ในหน้าจอประเภทต่างๆ

SP

พิกเซลที่ปรับขนาดได้ - เป็นเหมือนหน่วย dp แต่จะถูกปรับสัดส่วนตามขนาดแบบอักษรของผู้ใช้

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

จะใช้อะไร & ความสัมพันธ์ระหว่าง px & dp

พิกเซลความหนาแน่นอิสระ (dp)

หน่วยพิกเซลเสมือนที่คุณควรใช้เมื่อกำหนดเค้าโครง UI เพื่อแสดงขนาดหรือตำแหน่งของเค้าโครงในลักษณะที่ไม่ขึ้นกับความหนาแน่น ดังที่อธิบายไว้ข้างต้นพิกเซลความหนาแน่นอิสระเทียบเท่ากับหนึ่งพิกเซลทางกายภาพบนหน้าจอ 160 dpi ซึ่งเป็นความหนาแน่นพื้นฐานที่ระบบคาดการณ์สำหรับหน้าจอความหนาแน่น "กลาง" ณ รันไทม์ระบบจะจัดการกับการปรับขนาดของหน่วย dp ตามความจำเป็นโดยขึ้นอยู่กับความหนาแน่นที่แท้จริงของหน้าจอที่ใช้งานอยู่ การแปลงหน่วย dp เป็นพิกเซลหน้าจอนั้นง่ายมาก:

px = dp * (dpi / 160)

ตัวอย่างเช่นบนหน้าจอ 240 dpi, 1 dp เท่ากับ 1.5 ฟิสิคัลพิกเซล คุณควรใช้หน่วย DP เมื่อกำหนด UI ของแอปพลิเคชันของคุณเพื่อให้แน่ใจว่าการแสดง UI ของคุณบนหน้าจอที่มีความหนาแน่นแตกต่างกัน

การเข้าใจพิกเซลเป็น DP และในทางกลับกันเป็นสิ่งสำคัญมาก (โดยเฉพาะอย่างยิ่งสำหรับการให้ค่า dp ที่แน่นอนแก่ทีมงานสร้างสรรค์)

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

• พยายามรับค่าพิกเซลทั้งหมดเป็นเลขคู่จากทีมครีเอทีฟ มิฉะนั้นการสูญเสียความแม่นยำจะเกิดขึ้นในขณะที่คูณกับ 0.5

px

มันอธิบายไว้ข้างต้น พยายามหลีกเลี่ยงในไฟล์เลย์เอาต์ แต่มีบางกรณีที่จำเป็นต้องมี px ตัวอย่างเช่นบรรทัดตัวแบ่ง ListView px ดีกว่าที่นี่เพื่อให้เส้นหนึ่งพิกเซลเป็นตัวแบ่งสำหรับความละเอียดหน้าจอทั้งหมด

SP

ใช้ sp สำหรับขนาดตัวอักษร จากนั้นจะเปลี่ยนเฉพาะแบบอักษรในแอปพลิเคชันขณะที่ขนาดแบบอักษรของอุปกรณ์เปลี่ยน (นั่นคือแสดง -> แบบอักษรบนอุปกรณ์) หากคุณต้องการเก็บแบบอักษรขนาดคงที่ไว้ในแอพคุณสามารถกำหนดขนาดตัวอักษรเป็น dp ในกรณีเช่นนี้มันจะไม่เปลี่ยนแปลง นักพัฒนาอาจได้รับข้อกำหนดเช่นนี้สำหรับหน้าจอบางหน้าซึ่งผู้พัฒนาสามารถใช้ dp แทน sp ในกรณีอื่น ๆ แนะนำให้ใช้ sp

คุณสามารถเห็นความแตกต่างระหว่างpxและdpจากภาพด้านล่างและคุณยังสามารถพบว่าpxและdpไม่สามารถรับประกันขนาดร่างกายเดียวกันบนหน้าจอที่แตกต่างกัน

อะไรที่เกี่ยวข้องกับขนาดของข้อความและลักษณะต้องใช้หรือsp ptในขณะที่สิ่งที่เกี่ยวข้องกับขนาดของการควบคุมรูปแบบ ฯลฯ dpจะต้องใช้ด้วย

คุณสามารถใช้ทั้งในdpและdipในสถานที่

ฉันจะใช้ dp เท่านั้น

มีการพูดคุยกันมากมายเกี่ยวกับการใช้ "sp" สำหรับขนาดตัวอักษรและในขณะที่ฉันชื่นชมจุดนั้นฉันไม่คิดว่ามันเป็นสิ่งที่ถูกต้องที่จะทำจากมุมมองของการออกแบบ คุณสามารถทำลายการออกแบบของคุณได้หากผู้ใช้มีการเลือกขนาดตัวอักษรที่ไม่เกะกะและผู้ใช้จะต้องโทษแอพและไม่ใช่ทางเลือกในชีวิตของพวกเขาเอง

นอกจากนี้หากคุณใช้แอพ sp-font บนแท็บเล็ต 160 dpi คุณจะพบว่าทุกอย่างมีขนาดใหญ่ขึ้น ... แต่แบบอักษรของคุณจะดูเล็กเมื่อเปรียบเทียบ มันไม่ได้ดูดี

ในขณะที่ความคิดของแบบอักษร "sp" มีจิตใจที่ดี แต่เป็นความคิดที่ไม่ดี ติดกับ dp สำหรับทุกสิ่ง

sp = สเกลอิสระพิกเซล

dp = dip = พิกเซลอิสระหนาแน่น

dpi = จุดต่อนิ้ว

เราควรหลีกเลี่ยงการใช้SP

เราควรใช้dpเพื่อรองรับหน้าจอหลายหน้าจอ

Android รองรับความละเอียดหน้าจอที่แตกต่างกัน

• ldpi (ต่ำ) ~ 120 dpi
• mdpi (ปานกลาง) ~ 160 dpi
• hdpi (สูง) ~ 240 dpi
• xhdpi (สูงเป็นพิเศษ) ~ 320 dpi
• xxhdpi (สูงเป็นพิเศษมาก) ~ 480 dpi
• xxxhdpi (สูงเป็นพิเศษมากเป็นพิเศษ) ~ 640 dpi

อุปกรณ์ 120 dp ldpi มี 120 พิกเซลในขนาด 1 นิ้ว

เช่นเดียวกันสำหรับความหนาแน่นอื่น ๆ ...

เราในฐานะวิศวกรซอฟต์แวร์ควรใช้สูตรการแปลงนี้:

พิกเซล = dp * (ความหนาแน่น / 160)

ดังนั้น 1 dp ของอุปกรณ์ 240 dpi จะมี = 1 * (240/160) = 3/2 = 1.5 พิกเซล

และขนาด 1 dp ของอุปกรณ์ 480 dpi จะมี = 1 * (480/160) = 3 พิกเซล

ด้วยการใช้ความรู้ 1.5 และ 3 พิกเซลวิศวกรซอฟต์แวร์สามารถออกแบบเค้าโครงสำหรับความหนาแน่นต่าง

วิธีตรวจสอบพารามิเตอร์หน้าจอของอุปกรณ์ใด ๆ :

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

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

ความแตกต่างระหว่างdpและspหน่วยที่กล่าวถึงว่า " การตั้งค่าขนาดตัวอักษรของผู้ใช้ " โดยคำตอบที่คัดลอกมาจากเอกสารอย่างเป็นทางการสามารถดูได้ในเวลาทำงานโดยการเปลี่ยนตัวSettings->Accessibility->Large Textเลือก

Large Textตัวเลือกบังคับให้ข้อความกลายเป็น1.3ครั้งใหญ่

private static final float LARGE_FONT_SCALE = 1.3f;

นี้อาจจะดีแน่นอนขึ้นอยู่กับผู้ขายเพราะมันอยู่ในแพคเกจ / ปพลิเคชัน / การตั้งค่า

dpi -

• จุดต่อนิ้ว
• การวัดความหนาแน่นของพิกเซลของหน้าจอ

px - pixel

• สำหรับการแมปพิกเซลหน้าจอ

pt - คะแนน

• ประมาณ 1/72 ของนิ้วเกี่ยวกับขนาดหน้าจอทางกายภาพ

นิ้ว - เกี่ยวกับขนาดหน้าจอทางกายภาพ (1 นิ้ว = 2.54 ซม.)

mm- milimeter - ตามขนาดหน้าจอจริง

sp - พิกเซลที่ปรับขนาดได้

• ขึ้นอยู่กับการตั้งค่าขนาดตัวอักษรของผู้ใช้
• แบบอักษรควรอยู่ใน 'sp'

จุ่ม -

• จุ่ม == dp
• ความหนาแน่นของพิกเซลอิสระ
• มันแตกต่างกันไปตามความหนาแน่นของหน้าจอ
• ในหน้าจอ 160 dpi, 1 dp = 1 พิกเซล
• ใช้ dp ยกเว้นขนาดตัวอักษรของข้อความ

ในมาตรฐานจะใช้ dp และ sp sp สำหรับขนาดตัวอักษรและ dp สำหรับทุกอย่าง

สูตรสำหรับการแปลงหน่วย:

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  

นี่คือสูตรที่ใช้โดย Android:

px = dp * (dpi / 160)

โดยที่ dpi เป็นหนึ่งในความหนาแน่นของหน้าจอต่อไปนี้ สำหรับรายการความหนาแน่นที่เป็นไปได้ทั้งหมดไปที่นี่

มันกำหนดค่าคงที่ "DENSITY_ *"

• ldpi (ต่ำ) ~ 120dpi
• mdpi (ปานกลาง) ~ 160dpi
• hdpi (สูง) ~ 240dpi
• xhdpi (สูงเป็นพิเศษ) ~ 320dpi
• xxhdpi (สูงเป็นพิเศษมาก) ~ 480dpi
• xxxhdpi (สูงเป็นพิเศษมากเป็นพิเศษ) ~ 640dpi

ที่นำมาจากที่นี่

วิธีนี้จะทำให้เกิดความสับสนมากเมื่อแปลระหว่าง px และ dp ถ้าคุณรู้ว่าหน้าจอ dpi ของคุณ

สมมติว่าคุณต้องการภาพที่ 60 dp สำหรับหน้าจอ hdpi ขนาดฟิสิคัลพิกเซลที่ 60 dp คือ:

px = 60 * (240 / 160)

ขนาดหน้าจอในAndroidการจัดกลุ่มเป็นหมวดหมู่small, medium, large, extra large, และdouble-extra triple-extraความหนาแน่นของหน้าจอคือจำนวนพิกเซลภายในพื้นที่ (เช่นนิ้ว) ของหน้าจอ โดยทั่วไปจะวัดเป็นจุดต่อนิ้ว (dpi) ความหนาแน่นของหน้าจอถูกจัดกลุ่มเป็นต่ำปานกลางสูงและสูงเป็นพิเศษ ความละเอียดคือจำนวนพิกเซลทั้งหมดในหน้าจอ

• dp:ความหนาแน่นของพิกเซลอิสระมันแตกต่างกันไปตามความหนาแน่นของหน้าจอ ในหน้าจอ 160 dpi, 1 dp = 1 พิกเซล ยกเว้นขนาดตัวอักษรใช้ dp เสมอ
• จุ่ม:จุ่ม == dp ในรุ่น Android ก่อนหน้านี้ถูกนำมาใช้และเปลี่ยนเป็น dp ในภายหลัง
• sp:ปรับขนาดพิกเซลอิสระปรับขนาดตามการกำหนดขนาดตัวอักษรของผู้ใช้ แบบอักษรควรใช้ sp.
• px:พิกเซลมาตรฐานปกติของเราซึ่งจับคู่กับพิกเซลหน้าจอ
• เป็น:นิ้วโดยเทียบกับขนาดหน้าจอจริง
• mm:มิลลิเมตรที่เกี่ยวกับขนาดของหน้าจอแบบฟิสิคัล
• pt: 1/72 ของนิ้วโดยเทียบกับขนาดหน้าจอแบบฟิสิคัล

สูตรการแปลงระหว่างหน่วย

 px = dp * (dpi / 160)

dp ถึง px ในอุปกรณ์

ตัวอย่างต่อไปนี้อาจช่วยให้เข้าใจดีขึ้น การขยายเกิดขึ้นตามขนาดที่ฝากข้อมูล 120 (ldpi), 160 (mdpi), 240 (hdpi), 320 (xhdpi), 480 (xxhdpi) และ 640 (xxxhdpi) อัตราส่วนที่ Google แนะนำสำหรับการออกแบบคือ 3: 4: 6: 8: 12 สำหรับ ldpi: mdpi: hdpi: xhdpi: xxhdpi

รูปภาพขนาด 150px X 150px จะใช้งานได้

• 150 dp X 150 dp พื้นที่หน้าจอเป็น mdpi
• 100 dp X 100 dp พื้นที่หน้าจอเป็น hdpi
• 75 dp X 75 dp พื้นที่หน้าจอเป็น xhdpi

คุณสามารถใช้เครื่องคิดเลข DPI ต่อไปนี้เพื่อกำหนดขนาดภาพและขนาดอื่น ๆ ของคุณเมื่อคุณต้องการให้มีการออกแบบ UI ที่เหมือนกันในอุปกรณ์ Android ทั้งหมด

เครื่องคิดเลข DPI ใน Java

/*
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);        
   }
}

ข้อมูลเพิ่มเติมอ้างอิงลิงค์ต่อไปนี้

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

โปรดอ่านคำตอบจากวิกิชุมชน ด้านล่างนี้เป็นข้อมูลที่ต้องพิจารณาเพิ่มเติมจากคำตอบข้างต้น นักพัฒนาระบบ Android ส่วนใหญ่คิดถึงสิ่งนี้ในขณะที่กำลังพัฒนาแอพดังนั้นฉันจึงเพิ่มจุดเหล่านี้

sp = สเกลอิสระพิกเซล

dp = พิกเซลอิสระหนาแน่น

dpi = พิกเซลความหนาแน่น

ฉันได้รับคำตอบข้างต้นแล้ว ... ไม่พบคำตอบที่ถูกต้อง sp สำหรับขนาดตัวอักษร dp สำหรับขอบเขตเลย์เอาต์ - มาตรฐาน แต่sp สำหรับขนาดตัวอักษรจะทำลายเลย์เอาต์ถ้าใช้อย่างไม่ระมัดระวังในอุปกรณ์ส่วนใหญ่

sp ใช้ textize ของอุปกรณ์ในขณะที่ dp ใช้มาตรฐานความหนาแน่นของอุปกรณ์ (ไม่เคยเปลี่ยนอุปกรณ์) พูดว่าข้อความ 100sp สามารถใช้ 80% ของหน้าจอหรือ 100% ของหน้าจอขึ้นอยู่กับขนาดตัวอักษรที่ตั้งไว้ในอุปกรณ์

คุณสามารถใช้ sp สำหรับขอบเขตเลย์เอาต์ได้เช่นกันมันจะทำงาน :) ไม่มีแอปมาตรฐานใช้ sp สำหรับข้อความทั้งหมด

ใช้ sp และ dp สำหรับขนาดตัวอักษรโดยพิจารณาจาก UX

• อย่าใช้ sp สำหรับข้อความในแถบเครื่องมือ (สามารถใช้ Android dimens สำหรับขนาดหน้าจอที่แตกต่างกับ dp)
• อย่าใช้ sp สำหรับข้อความในปุ่มเล็ก ๆ ที่มีขอบเขตข้อความที่เล็กมาก ฯลฯ

บางคนใช้ขนาด FONT ขนาดใหญ่ในโทรศัพท์ของพวกเขาเพื่อให้อ่านง่ายขึ้นการให้ข้อความที่มีขนาดเล็กที่มีการเข้ารหัสยากจะเป็นปัญหา UX ใส่ sp สำหรับข้อความที่จำเป็น แต่ให้แน่ใจว่าจะไม่ทำลายเค้าโครงเมื่อผู้ใช้เปลี่ยนการตั้งค่าของเขา

ในทำนองเดียวกันหากคุณมีแอปเดียวที่รองรับทุกมิติการเพิ่มเนื้อหา xxxhdpi จะเพิ่มขนาดแอปให้มากขึ้น แต่ตอนนี้โทรศัพท์ xxxhdpi นั้นเป็นเรื่องธรรมดาดังนั้นเราต้องรวมเนื้อหา xxxhdpi ไว้อย่างน้อยสำหรับไอคอนในแถบด้านข้างแถบเครื่องมือและแถบด้านล่าง เป็นการดีกว่าที่จะย้ายไปที่ภาพเวกเตอร์เพื่อให้ได้ภาพที่มีคุณภาพสม่ำเสมอและดีกว่าสำหรับทุกขนาดหน้าจอ

โปรดทราบด้วยว่าผู้คนใช้ตัวอักษรที่กำหนดเองในโทรศัพท์ ดังนั้นการขาดแบบอักษรอาจทำให้เกิดปัญหาเกี่ยวกับระยะห่างและทั้งหมด สมมติว่าขนาดตัวอักษร 12sp สำหรับแบบอักษรที่กำหนดเองอาจใช้พิกเซลเกินกว่าแบบอักษรเริ่มต้นบางส่วน

อ้างถึงเว็บไซต์สำหรับนักพัฒนาของ Google เพื่อรับหน้าจอและรายละเอียดความหนาแน่นสำหรับ Android https://developer.android.com/training/multiscreen/screendensities

• px - หนึ่งพิกเซลเหมือนกับที่ใช้ใน CSS, JavaScript และอื่น ๆ
• sp - พิกเซลที่ปรับขนาดได้
• จิ้ม - พิกเซลแบบหนาแน่น

โดยทั่วไปแล้ว sp จะใช้สำหรับขนาดตัวอักษรในขณะที่ใช้ dip (หรือที่เรียกว่า dp) สำหรับผู้อื่น

ฉันเจอบทความที่ดีเกี่ยวกับการออกแบบ UI ของแอพ Android สำหรับความละเอียดหน้าจอที่แตกต่างกันและฉันอยากจะทิ้งไว้ที่นี่เพียงเพื่อคนที่กำลังค้นหาในบริเวณนี้ ใช่ฉันรู้ว่ามีการอธิบายไว้ใน Google เอกสาร (และกล่าวถึงในโพสต์ด้านบน) ฉันอ่านว่า แต่มันไม่ดีสำหรับฉัน (ใช่ฉันอาจจะโง่เกินไป) มันยังไม่ชัดเจนสำหรับฉันเกี่ยวกับวิธีออกแบบเลย์เอาต์ที่สามารถรองรับขนาดหน้าจอที่แตกต่างกันได้ ฉันเกลียดแนวคิด DP และอื่น ๆ เมื่อฉันต้องใช้เค้าโครง UI "ยืดหยุ่น" สำหรับหน้าจอที่แตกต่างกัน (เฮ้นักพัฒนา iOS - ใช่คุณคิดถูกแล้วว่าเป็นเรื่องสตอรีบอร์ด)

Android ไม่มีแนวคิด UI ที่ไม่ดี แต่ขาดคุณสมบัติ iOS Storyboard น่าเสียดาย การออกแบบ UI ที่ยืดหยุ่นใน Android ไม่ใช่เรื่องง่าย (ที่ดีที่สุด)

ต่อไปนี้เป็นบทความที่ช่วยให้ฉันเข้าใจสิ่งที่ต้องทำใน Android เพื่อสร้างเลย์เอาต์สำหรับขนาดหน้าจอที่แตกต่างกัน:

บล็อก JMSTUDIO: - ตัดสินใจขนาดหน้าจอ Android App

วิธีการออกแบบ UI สำหรับแอพ Android สำหรับขนาดหน้าจอที่แตกต่างกัน

ในการออกแบบ UI แอพสำหรับขนาดหน้าจอที่แตกต่างกันการออกแบบเริ่มต้นของเราจะต้องมีพื้นที่ว่างขั้นต่ำสำหรับแต่ละขนาดหน้าจอ Android กำหนดขนาดต่ำสุด (เป็น dp) สำหรับหน้าจอทั่วไปแต่ละประเภท นี่คือแนวทางขนาดหน้าจอ Android เมื่อเราได้ขนาดหน้าจอเป็น dp มันไม่เพียงพอที่เราจะออกแบบ UI ของแอพ Android สำหรับแต่ละขนาดหน้าจอเราจำเป็นต้องเตรียมกราฟิกและรูปภาพบิตแมปสำหรับแต่ละความหนาแน่น นี่คือแนวทางความหนาแน่นของหน้าจอ Android

เพื่อการคำนวณอย่างง่ายเราสามารถติดตามอัตราส่วนการปรับอัตราส่วน 3: 4: 6: 8 ระหว่างความหนาแน่นทั่วไปสี่แบบ หากเราสร้างรูปภาพขนาด 36x36 พิกเซลสำหรับอุปกรณ์ ldpi ขนาดความหนาแน่นของส่วนที่เหลือจะเป็น 48 × 48 สำหรับ mdpi, 72 × 72 สำหรับ hdpi และ 96 × 96 สำหรับ xhdpi

วิธีการออกแบบ UI แอพ Android ใน Photoshop

นักออกแบบหลายคนมีปัญหาในการออกแบบ UI แอพ Android ใน photoshop หรือเครื่องมือออกแบบกราฟิกแบบพิกเซลอื่น ๆ เนื่องจากหน่วยความหนาแน่นอิสระ, dp นักออกแบบไม่ทราบวิธีแมป dp กับพิกเซล Google ยังไม่ได้ให้คำแนะนำการออกแบบ UI Android ที่ชัดเจนสำหรับพวกเขาแม้ว่าพวกเขาจะให้สูตรพื้นฐานสำหรับการแปล DP และพิกเซล

ตามคำนิยามของ Android นั้น 1pd เท่ากับ 1px น้อยกว่า 160 dpi อุปกรณ์ (mdpi) ดังนั้นเราต้องการออกแบบแอพ Android สำหรับอุปกรณ์ Android ขนาดใหญ่ที่มีความหนาแน่น mdpi เราสามารถกำหนดขนาด UI เป็นพิกเซลกว้าง 960 พิกเซลและ 720px สูง ปฏิบัติตามกฎการแมปเดียวกันเราจะได้รับแนวทางการออกแบบ UI ขนาดหน้าจอ Android App ดังต่อไปนี้:

เพิ่ม : หากคุณสนใจ UI "ยืดหยุ่น" ด้วยดูที่ห้องสมุดนี้: Android SDK ที่มีหน่วยขนาดใหม่ - sdp (ปรับขนาดได้ dp) หน่วยขนาดนี้ปรับขนาดด้วยขนาดหน้าจอ (นี่ยังกล่าวถึงในคำตอบที่นี่เกี่ยวกับSDPห้องสมุด)

ในที่สุดADDED2 Google ได้เข้าใจถึงประโยชน์ของแนวคิด UI Storeboard UI แล้วและนี่ก็ConstraintLayoutเป็นโลกของ Android: สร้าง UI ที่ตอบสนองได้ด้วย ConstraintLayout

1) dp: (density independent pixels)

จำนวนพิกเซลที่แสดงในหน่วยหนึ่งของ dp จะเพิ่มขึ้นตามความละเอียดหน้าจอที่เพิ่มขึ้น (เมื่อคุณมีจุด / พิกเซลต่อนิ้วมากขึ้น) ตรงกันข้ามกับอุปกรณ์ที่มีความละเอียดต่ำกว่าจำนวนพิกเซลที่แสดงในหน่วย dp จะลดลง เนื่องจากนี่เป็นหน่วยที่เกี่ยวข้องจึงต้องมีการเปรียบเทียบพื้นฐาน พื้นฐานนี้เป็นหน้าจอ 160 dpi นี่คือสมการ:px = dp * (dpi / 160).

2) sp: (scale independent pixels)

หน่วยนี้ปรับขนาดตามหน้าจอ dpi (คล้ายกับ dp) เช่นเดียวกับการตั้งค่าขนาดแบบอักษรของผู้ใช้

3) px: (pixels)

พิกเซลหรือจุดที่แท้จริงบนหน้าจอ

สำหรับรายละเอียดเพิ่มเติมคุณสามารถเยี่ยมชม

คู่มือนักพัฒนา Android> Dimension
คู่มือนักพัฒนา Android> หน้าจอ

ขนาดหน้าจอใน Android จะถูกจัดกลุ่มเป็นหมวดหมู่ldpi, mdpi, hdpi, xhdpi, และxxhdpi ความหนาแน่นของหน้าจอคือจำนวนพิกเซลภายในพื้นที่ (เช่นนิ้ว) ของหน้าจอ โดยทั่วไปจะวัดเป็นจุดต่อนิ้ว ( )xxxhdpidpi

PX(Pixels):

• พิกเซลมาตรฐานปกติของเราซึ่งจับคู่กับพิกเซลหน้าจอ pxมีความหมายสำหรับพิกเซลแน่นอน สิ่งนี้ถูกใช้ถ้าคุณต้องการให้เป็นพิกเซลสมบูรณ์สำหรับความกว้างหรือความสูง ไม่แนะนำ.

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

• dip == dp. ในรุ่นก่อนหน้าของ Android dpจุ่มถูกนำมาใช้และต่อมาเปลี่ยนเป็น pxนี่คือทางเลือกของการ

• โดยทั่วไปเราไม่เคยใช้pxเพราะมันเป็นค่าสัมบูรณ์ หากคุณใช้pxเพื่อตั้งค่าความกว้างหรือความสูงและหากมีการดาวน์โหลดแอปพลิเคชันลงในอุปกรณ์ที่มีขนาดหน้าจอที่แตกต่างกันมุมมองนั้นจะไม่ยืดตามขนาดดั้งเดิมของหน้าจอ

• dppxขอแนะนำให้ใช้ในสถานที่ของ ใช้dpหากคุณต้องการพูดถึงความกว้างและความสูงเพื่อขยายและย่อขนาดตามขนาดหน้าจอ

• ถ้าเราให้dp/dipAndroid จะคำนวณขนาดพิกเซลโดยอัตโนมัติบนหน้าจอขนาด 160 พิกเซล

SP(Scale independent pixels):

• ปรับขนาดตามความต้องการขนาดตัวอักษรของผู้ใช้ spควรใช้แบบอักษร

• เมื่อกล่าวขวัญขนาดตัวอักษรให้พอดีกับหน้าจอขนาดต่าง ๆ spการใช้งาน สิ่งนี้คล้ายกับdp. ใช้spโดยเฉพาะอย่างยิ่งสำหรับขนาดแบบอักษรเพื่อขยายและย่อขนาดตามขนาดหน้าจอ

เอกสาร Android พูดว่า:

เมื่อระบุส่วนข้อมูลให้ใช้อย่างใดอย่างหนึ่งdpหรือspหน่วยเสมอ dpเป็นความหนาแน่นของพิกเซลที่เป็นอิสระที่สอดคล้องกับขนาดร่างกายของพิกเซลที่ dpi160 An spเป็นหน่วยพื้นฐานเดียวกัน แต่ปรับขนาดตามขนาดข้อความที่ผู้ใช้ต้องการ (เป็นพิกเซลที่ไม่ขึ้นกับขนาด) ดังนั้นคุณควรใช้หน่วยการวัดนี้เมื่อกำหนดขนาดตัวอักษร

หน้าจอของโทรศัพท์มือถือที่ถูกสร้างขึ้นจากหลายพันจุดเล็ก ๆ ที่รู้จักกันเป็นพิกเซล (พิกเซล) พิกเซลเป็นองค์ประกอบที่เล็กที่สุดที่จะทำให้ภาพ ยิ่งจำนวนพิกเซลมากขึ้นในการสร้างภาพหรือถ้อยคำมากเท่าไรภาพก็ยิ่งคมชัดขึ้นและทำให้หน้าจอสมาร์ทโฟนอ่านง่ายขึ้น

ความละเอียดหน้าจอวัดจากจำนวนพิกเซลบนหน้าจอ ความละเอียดหน้าจอเป็นข้อกำหนดเฉพาะที่ใช้กันทั่วไปเมื่อซื้ออุปกรณ์ แต่จริงๆแล้วมันไม่ได้มีประโยชน์เมื่อออกแบบสำหรับ Android เพราะการคิดหน้าจอในแง่ของพิกเซลจะไม่สนใจความคิดขนาดจริงซึ่งสำหรับอุปกรณ์สัมผัสมีความสำคัญจริงๆ

ความหนาแน่นของพิกเซลอิสระ (dp หรือ dip)อนุญาตให้ผู้ออกแบบสร้างเนื้อหาที่ปรากฏในลักษณะที่คาดหวังไม่ว่าจะมีความละเอียดหรือความหนาแน่นของอุปกรณ์เป้าหมาย

พิกเซลความหนาแน่นอิสระ (dp หรือ dip) เท่ากับหนึ่งพิกเซลที่ความหนาแน่นพื้นฐานหรือ 160 dpi (จุดต่อนิ้ว)

1 px / 1dp = 160 dpi / 160 dpi

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

ที่ไหน

dpi คือจุดต่อนิ้ว

ดังนั้นที่ 320 dpi, 1 dp เท่ากับ 2 px

สูตร

px / dp = dpi / 160dpi

จุดต่อนิ้ว (dpi) เป็นการวัดความคมชัด (นั่นคือความหนาแน่นของจุดสว่าง) บนหน้าจอแสดงผล จุดต่อนิ้วสำหรับความละเอียดของภาพที่กำหนดจะแตกต่างกันไปตามขนาดหน้าจอโดยรวมเนื่องจากจำนวนพิกเซลเดียวกันกระจายออกไปในพื้นที่ที่แตกต่างกัน

การทำงานกับพิกเซลอิสระที่หนาแน่นช่วยให้เราจัดการกับสถานการณ์เช่นที่คุณมีอุปกรณ์สองชิ้นที่มีความละเอียดพิกเซลเท่ากัน แต่มีพื้นที่ว่างแตกต่างกัน สมมติว่าแท็บเล็ตและโทรศัพท์มีความละเอียดพิกเซลเท่ากับ 1280 x 800 พิกเซล (160 dpi) และ 800 x 1280 พิกเซล (320 dpi) ตามลำดับ

ตอนนี้เนื่องจากแท็บเล็ตมีความหนาแน่นพื้นฐาน (160 dpi) ขนาดพิกเซลทางกายภาพและความหนาแน่นของมันเท่ากันคือ 1280 คูณ 800 โทรศัพท์ในทางกลับกันมีความหนาแน่นของพิกเซลสูงกว่าดังนั้นจึงมีพิกเซลหนาแน่นอิสระครึ่งเท่าทางกายภาพ พิกเซล ดังนั้นโทรศัพท์จึงมีพิกเซลอิสระหนาแน่น 400 ถึง 640 พิกเซล ดังนั้นการใช้พิกเซลที่ไม่ขึ้นกับความหนาแน่นทำให้ภาพทางจิตใจง่ายขึ้นว่าแท็บเล็ตมีพื้นที่มากกว่าโทรศัพท์มาก

ในทำนองเดียวกันหากคุณมีอุปกรณ์สองเครื่องที่มีขนาดหน้าจอที่คล้ายกัน แต่ความหนาแน่นของพิกเซลที่แตกต่างกันบอกว่าหนึ่งคือ 800 คูณ 1280 พิกเซล (320 dpi) และอีกอันคือ 400 คูณ 640 พิกเซล (160 dpi) เราไม่จำเป็นต้องกำหนดทั้งหมด เลย์เอาต์ที่แตกต่างกันสำหรับอุปกรณ์ทั้งสองนี้เนื่องจากเราสามารถวัดสินทรัพย์ในรูปของพิกเซลอิสระแบบหนาแน่นซึ่งเหมือนกันสำหรับอุปกรณ์ทั้งสอง

800 คูณ 1280 พิกเซล (320dpi) = 400 โดย 640 พิกเซลอิสระหนาแน่น (dp)

400 x 640 พิกเซล (160 dpi) = 400 x 640 พิกเซลอิสระหนาแน่น (dp)

สเกลอิสระพิกเซล (sp)เป็นหน่วยที่ต้องการสำหรับขนาดตัวอักษร เพื่อวัตถุประสงค์ในการเข้าถึง Android อนุญาตให้ผู้ใช้ปรับขนาดแบบอักษรของอุปกรณ์ ผู้ใช้ที่มีปัญหาในการอ่านข้อความสามารถเพิ่มขนาดตัวอักษรของอุปกรณ์ได้ ปกติคุณจะพบตัวเลือกนี้ในการตั้งค่าการแสดงผลบนโทรศัพท์หรือแท็บเล็ตภายใต้ขนาดตัวอักษร บ่อยครั้งที่มันสามารถใช้ได้ผ่านการตั้งค่าการเข้าถึง

ด้วยพิกเซลที่แยกอิสระขนาด 16 sp นั้นเหมือนกับ 16 dp เมื่อขนาดตัวอักษรของอุปกรณ์เป็นปกติหรือ 100% แต่เมื่อขนาดตัวอักษรของอุปกรณ์มีขนาดใหญ่เช่น 125%, 16 sp จะแปลเป็น 20 dp หรือ 1.25 เท่า 16

หากคุณใช้ dp เป็นหน่วยสำหรับขนาดตัวอักษรชิ้นส่วนของข้อความนั้นจะมีขนาดทางกายภาพที่เฉพาะเจาะจงไม่ว่าผู้ใช้จะกำหนดขนาดตัวอักษรของอุปกรณ์ การใช้หน่วย sp จะทำให้ประสบการณ์ที่ดีขึ้นสำหรับผู้ที่มีสายตาบกพร่อง

การอ้างอิง : Udacity , Google

sp: สเกลอิสระพิกเซล

คุณควรใช้กับข้อความเนื่องจากถูกปรับขนาดโดยอัตโนมัติตามขนาดตัวอักษรที่ผู้ใช้ใช้ในอุปกรณ์ของเขา

px: องค์ประกอบพิกเซลหรือรูปภาพเป็นจุดเดียวบนหน้าจอ

ความหนาแน่นของพิกเซล

ความหนาแน่นของพิกเซลหน้าจอและความละเอียดแตกต่างกันไปขึ้นอยู่กับแพลตฟอร์ม พิกเซลที่ไม่ขึ้นกับอุปกรณ์และพิกเซลที่ปรับขนาดได้เป็นหน่วยที่ให้ความยืดหยุ่นในการรองรับการออกแบบข้ามแพลตฟอร์ม

การคำนวณความหนาแน่นของพิกเซล

จำนวนพิกเซลที่พอดีกับนิ้วเรียกว่าความหนาแน่นของพิกเซล หน้าจอความหนาแน่นสูงมีพิกเซลต่อนิ้วมากกว่าหน้าจอที่มีความหนาแน่นต่ำ ...

จำนวนพิกเซลที่พอดีกับนิ้วเรียกว่าความหนาแน่นของพิกเซล หน้าจอความหนาแน่นสูงมีพิกเซลต่อนิ้วมากกว่าหน้าจอที่มีความหนาแน่นต่ำ ด้วยเหตุนี้องค์ประกอบ UI ของขนาดพิกเซลเดียวกันจึงมีขนาดใหญ่ขึ้นบนหน้าจอที่มีความหนาแน่นต่ำและมีขนาดเล็กลงบนหน้าจอที่มีความหนาแน่นสูง

ในการคำนวณความหนาแน่นของหน้าจอคุณสามารถใช้สมการนี้:

ความหนาแน่นของหน้าจอ = ความกว้างของหน้าจอ (หรือความสูง) เป็นพิกเซล / ความกว้างของหน้าจอ (หรือความสูง) เป็นนิ้ว

ความหนาแน่นอิสระ

ความหนาแน่นของพิกเซลหน้าจอและความละเอียดแตกต่างกันไปขึ้นอยู่กับแพลตฟอร์ม พิกเซลที่ไม่ขึ้นกับอุปกรณ์และพิกเซลที่ปรับขนาดได้เป็นหน่วยที่ให้ความยืดหยุ่นในการรองรับการออกแบบข้ามแพลตฟอร์ม

การคำนวณความหนาแน่นของพิกเซลจำนวนพิกเซลที่พอดีกับนิ้วจะเรียกว่าเป็นความหนาแน่นของพิกเซล หน้าจอความหนาแน่นสูงมีพิกเซลต่อนิ้วมากกว่าหน้าจอที่มีความหนาแน่นต่ำ ...

ความเป็นอิสระของความหนาแน่นหมายถึงการแสดงผลที่สม่ำเสมอขององค์ประกอบ UI บนหน้าจอที่มีความหนาแน่นต่างกัน

พิกเซลความหนาแน่นอิสระเขียนเป็นdp (ออกเสียง“ dips ”) เป็นหน่วยที่ยืดหยุ่นที่ปรับขนาดให้มีขนาดที่เท่ากันทุกหน้าจอ วัสดุ UIs ใช้พิกเซลที่มีความหนาแน่นอิสระเพื่อแสดงองค์ประกอบอย่างสม่ำเสมอบนหน้าจอที่มีความหนาแน่นต่างกัน

1. หน้าจอความหนาแน่นต่ำแสดงขึ้นพร้อมความหนาแน่นอิสระ
2. หน้าจอความหนาแน่นสูงแสดงขึ้นพร้อมความหนาแน่นแบบอิสระ

อ่านข้อความเต็ม https://material.io/design/layout/pixel-density.html

พิกเซล (px) - สอดคล้องกับพิกเซลจริงบนหน้าจอ สิ่งนี้ถูกใช้ถ้าคุณต้องการให้เป็นพิกเซลสมบูรณ์สำหรับความกว้างหรือความสูง

พิกเซลความหนาแน่นอิสระ (dp หรือ dip) - หน่วยนามธรรมที่ขึ้นอยู่กับความหนาแน่นทางกายภาพของหน้าจอ หน่วยเหล่านี้สัมพันธ์กับหน้าจอ 160 dpi ดังนั้นหนึ่ง dp คือหนึ่งพิกเซลบนหน้าจอ 160 dpi อัตราส่วนของพิกเซลต่อพิกเซลจะเปลี่ยนตามความหนาแน่นของหน้าจอ แต่ไม่จำเป็นต้องเป็นสัดส่วนโดยตรง หมายเหตุ: คอมไพเลอร์ยอมรับทั้ง "จุ่ม" และ "dp" แม้ว่า "dp" จะสอดคล้องกับ "sp" มากขึ้น

พิกเซลที่ปรับขนาดได้ (sp) - เป็นเหมือนหน่วย dp แต่จะถูกปรับสัดส่วนตามขนาดตัวอักษรของผู้ใช้ ขอแนะนำให้คุณใช้หน่วยนี้เมื่อระบุขนาดตัวอักษรดังนั้นพวกเขาจะถูกปรับสำหรับทั้งความหนาแน่นของหน้าจอและความต้องการของผู้ใช้

ใช้ dp และ sp เท่านั้น sp สำหรับขนาดตัวอักษรและ dp สำหรับทุกอย่าง มันจะทำให้ UI เข้ากันได้กับอุปกรณ์ Android ที่มีความหนาแน่นต่างกัน คุณสามารถเรียนรู้เพิ่มเติมเกี่ยวกับพิกเซลและ DP ได้จาก https://www.google.com/design/spec/layout/units-measurements.html#units-measurements-density-indrants-pixels-dp-

URL ที่มา: - http://www.androidtutorialshub.com/what-is-the-difference-between-px-dp-dip-sp-on-android/

dpฉันต้องการที่จะให้เป็นวิธีที่ง่ายต่อการเข้าใจ อันที่จริงฉันคิดว่าdpเป็นวิธีที่เข้าใจง่ายที่สุด dpเป็นหน่วยความยาวทางกายภาพ มันเป็นเรื่องของมิติเช่นเดียวกับหรือmm inchมันสะดวกเพียงแค่ให้เราเขียน50dp, 60dpมากกว่า50/160 inchหรือ60/160 inchเพราะหนึ่งdpเป็นเพียง1/160 inchสิ่งที่ขนาดหน้าจอหรือมติ

ปัญหาเดียวก็คือว่า Android dpi ของบางหน้าจอไม่ถูกต้อง ตัวอย่างเช่นหน้าจอที่จัดเป็น 160dpi อาจมี 170dpi แน่นอน ดังนั้นผลการคำนวณของdpฟัซซี่ 1/160 inchมันควรจะเป็นประมาณเช่นเดียวกับ