การเร่งฮาร์ดแวร์

เริ่มตั้งแต่ Android 3.0 (API ระดับ 11) ไปป์ไลน์การแสดงภาพ 2 มิติของ Android จะรองรับฮาร์ดแวร์ การเร่งความเร็ว หมายความว่าการดำเนินการวาดทั้งหมดที่ดำเนินการใน ผืนผ้าใบของ View ใช้ GPU เนื่องจากต้องเพิ่มทรัพยากรที่จำเป็นสำหรับการเปิดใช้ การเร่งฮาร์ดแวร์จะทำให้แอปของคุณใช้ RAM มากขึ้น

ระบบจะเปิดใช้การเร่งฮาร์ดแวร์โดยค่าเริ่มต้นหากระดับ API เป้าหมายของคุณ >=14 แต่สามารถ เปิดใช้อย่างชัดแจ้ง หากแอปพลิเคชันของคุณใช้เฉพาะมุมมองมาตรฐานและ Drawable วินาที การเปิดใช้โดยรวมจะไม่ทำให้การวาดที่ไม่พึงประสงค์ เอฟเฟกต์ อย่างไรก็ตาม เนื่องจากการเร่งฮาร์ดแวร์ไม่ได้รับการสนับสนุนสำหรับการวาดภาพ 2 มิติทั้งหมด การดำเนินการ การเปิดอาจมีผลต่อมุมมองที่กำหนดเองหรือการดึงดูดการเรียก ปัญหา ปกติแล้วจะปรากฏออกมาเป็นองค์ประกอบที่มองไม่เห็น ข้อยกเว้น หรือเป็นพิกเซลที่แสดงผลไม่ถูกต้อง ถึง Android มีตัวเลือกให้คุณเปิดหรือปิดใช้ การเร่งฮาร์ดแวร์ ระดับต่างๆ ดูควบคุมการเร่งฮาร์ดแวร์

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

ดูข้อมูลเพิ่มเติมที่ OpenGL ที่ใช้ API เฟรมเวิร์ก และ Renderscript

ควบคุมการเร่งฮาร์ดแวร์

คุณสามารถควบคุมการเร่งฮาร์ดแวร์ได้ที่ระดับต่อไปนี้

• การสมัคร
• กิจกรรม
• หน้าต่าง
• ดู

ระดับแอปพลิเคชัน

ในไฟล์ Manifest ของ Android ให้เพิ่มแอตทริบิวต์ต่อไปนี้ลงในส่วน แท็ก <application> เพื่อเปิดใช้การเร่งฮาร์ดแวร์สำหรับทั้ง แอปพลิเคชัน:

<application android:hardwareAccelerated="true" ...>

ระดับกิจกรรม

หากแอปพลิเคชันของคุณทำงานไม่ถูกต้องหากเปิดการเร่งฮาร์ดแวร์ทั่วโลก ควบคุมกิจกรรมแต่ละอย่างได้ด้วย หากต้องการเปิดหรือปิดใช้การเร่งฮาร์ดแวร์ที่ ระดับกิจกรรมที่คุณสามารถใช้แอตทริบิวต์ android:hardwareAccelerated สำหรับ <activity> ตัวอย่างต่อไปนี้เปิดใช้การเร่งฮาร์ดแวร์สำหรับ ทั้งแอปพลิเคชัน แต่ปิดใช้สำหรับกิจกรรมเดียว

<application android:hardwareAccelerated="true">
    <activity ... />
    <activity android:hardwareAccelerated="false" />
</application>

ระดับหน้าต่าง

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

window.setFlags(
        WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED,
        WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED
)

getWindow().setFlags(
    WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED,
    WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED);

หมายเหตุ: ปัจจุบันคุณไม่สามารถปิดใช้การเร่งฮาร์ดแวร์ที่ ระดับหน้าต่าง

ระดับข้อมูลพร็อพเพอร์ตี้

คุณสามารถปิดใช้การเร่งฮาร์ดแวร์สำหรับมุมมองใดมุมมองหนึ่งขณะรันไทม์ด้วยฟังก์ชัน รหัสต่อไปนี้:

myView.setLayerType(View.LAYER_TYPE_SOFTWARE, null)

myView.setLayerType(View.LAYER_TYPE_SOFTWARE, null);

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

ระบุว่ามุมมองเป็นการเร่งฮาร์ดแวร์หรือไม่

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

คุณสามารถตรวจสอบว่าแอปพลิเคชันมีการเร่งความเร็วด้วยฮาร์ดแวร์หรือไม่มี 2 วิธีดังนี้

• View.isHardwareAccelerated() ทำรีเทิร์น true หากเชื่อมต่อ View กับฮาร์ดแวร์ที่เร่งการแสดงผล
• Canvas.isHardwareAccelerated() แสดงผล true หาก Canvas เป็นการเร่งฮาร์ดแวร์

หากคุณต้องทำการตรวจสอบนี้ในรหัสวาดของคุณ ให้ใช้ Canvas.isHardwareAccelerated() แทน ของ View.isHardwareAccelerated() หากเป็นไปได้ เมื่อการดู แนบอยู่กับหน้าต่างที่มีการเร่งความเร็วด้วยฮาร์ดแวร์ ก็ยังสามารถวาดได้โดยใช้ฮาร์ดแวร์ที่ไม่ใช่ฮาร์ดแวร์ Canvas แบบเร่ง ตัวอย่างเช่น เมื่อวาดมุมมองเป็นบิตแมปสำหรับการแคช วัตถุประสงค์

โมเดลภาพวาดของ Android

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

โมเดลการวาดภาพโดยใช้ซอฟต์แวร์

ในรูปแบบการวาดของซอฟต์แวร์ การดูจะวาดด้วย 2 ขั้นตอนต่อไปนี้

1. ทำให้ลำดับชั้นไม่ถูกต้อง
2. วาดลำดับชั้น

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

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

หมายเหตุ: มุมมองของ Android จะเรียกใช้ invalidate() โดยอัตโนมัติเมื่อคุณสมบัติมีการเปลี่ยนแปลง เช่น พื้นหลัง หรือข้อความใน TextView

โมเดลการวาดที่มีการเร่งฮาร์ดแวร์

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

1. ทำให้ลำดับชั้นไม่ถูกต้อง
2. บันทึกและอัปเดตรายการที่แสดง
3. วาดรายการแสดงผล

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

การใช้รายการที่แสดงก็ส่งผลดีต่อประสิทธิภาพของภาพเคลื่อนไหวเช่นกัน เนื่องจากการตั้งค่าคุณสมบัติเฉพาะ เช่น อัลฟาหรือการหมุนเวียน ไม่จำเป็นต้องทำให้มุมมองเป้าหมายเป็นโมฆะ (เนื่องจาก โดยอัตโนมัติ) การเพิ่มประสิทธิภาพนี้ยังนำไปใช้กับมุมมองที่มีรายการที่แสดง (ทุกๆ มุมมองเมื่อ แอปพลิเคชันมีการเร่งฮาร์ดแวร์) เช่น สมมติว่ามี LinearLayout ที่มี ListView อยู่เหนือ Button รายการที่แสดงสำหรับ LinearLayout มีลักษณะ ดังนี้

• DrawDisplayList(มุมมองรายการ)
• รายการแสดงการวาด(ปุ่ม)

ให้สมมติว่าในตอนนี้คุณต้องการเปลี่ยนความทึบแสงของ ListView หลัง กำลังเรียกใช้ setAlpha(0.5f) ใน ListView รายการที่แสดงตอนนี้ มี:

• SaveLayerAlpha(0.5)
• DrawDisplayList(มุมมองรายการ)
• คืนค่า
• รายการแสดงการวาด(ปุ่ม)

ไม่มีการเรียกใช้โค้ดภาพวาดที่ซับซ้อนของ ListView แต่ ระบบอัปเดตเฉพาะรายการแสดงผลของ LinearLayout ที่ใช้ง่ายขึ้นมาก ใน แอปพลิเคชันที่ไม่มีการเร่งฮาร์ดแวร์ รหัสวาดของทั้งรายการและ ผู้ปกครองจะดำเนินการอีกครั้ง

รองรับการดำเนินการวาด

เมื่อเร่งฮาร์ดแวร์ ไปป์ไลน์การแสดงผลแบบ 2 มิติจะสนับสนุนโหมดที่ใช้กันโดยทั่วไป Canvas วาดเขียนการดำเนินการ รวมถึงการดำเนินการที่ใช้น้อยหลายรายการ ทั้งหมด การวาดภาพที่ใช้ในการแสดงแอปพลิเคชันที่จัดส่งร่วมกับ Android, วิดเจ็ตเริ่มต้น และเลย์เอาต์ และเอฟเฟกต์ภาพขั้นสูงที่พบบ่อย เช่น การสะท้อนและพื้นผิวที่แบ่งชิ้นส่วน ที่รองรับ

ตารางต่อไปนี้อธิบายระดับการสนับสนุนของการดำเนินการต่างๆ ในระดับ API

การปรับขนาด Canvas

เราสร้างไปป์ไลน์การแสดงผล 2 มิติที่เร่งการแสดงผลด้วยฮาร์ดแวร์ขึ้นก่อนเพื่อรองรับการวาดที่ไม่มีการปรับขนาด โดยการดำเนินการวาดบางอย่างจะลดคุณภาพลงอย่างมากในค่าสเกลที่สูงกว่า เหล่านี้ การดำเนินการจะทำงานเป็นพื้นผิวที่วาดที่มาตราส่วน 1.0 ซึ่งเปลี่ยนรูปแบบโดย GPU เริ่มต้นใน API ระดับ 28 การวาดทั้งหมดสามารถปรับขนาดได้โดยไม่มีปัญหา

หมายเหตุ: "แบบง่าย" รูปทรงต่างๆ ได้แก่ drawRect() drawCircle(), drawOval(), drawRoundRect() และ drawArc() (มี useCenter=false) คำสั่งที่ออกโดยโปรแกรม Paint ที่ไม่มีส่วน PathEffect และไม่มีการรวมที่ไม่ใช่ค่าเริ่มต้น (ผ่าน setStrokeJoin() / setStrokeMiter()) อินสแตนซ์อื่นๆ ของคำสั่งวาดเหล่านี้จะอยู่ในส่วน "ซับซ้อน" ใน จากแผนภูมิด้านบน

ถ้าแอปพลิเคชันของคุณได้รับผลกระทบจากคุณลักษณะหรือข้อจำกัดใดๆ ที่ขาดหายไปเหล่านี้ คุณสามารถ ปิดการเร่งฮาร์ดแวร์เฉพาะในส่วนที่ได้รับผลกระทบของแอปพลิเคชันของคุณด้วยการเรียก setLayerType(View.LAYER_TYPE_SOFTWARE, null) วิธีนี้จะช่วยให้คุณ ยังคงใช้ประโยชน์จากการเร่งฮาร์ดแวร์ ในที่อื่นๆ ได้ ดูข้อมูลเพิ่มเติมเกี่ยวกับวิธีเปิดใช้ควบคุมการเร่งฮาร์ดแวร์ และปิดใช้การเร่งฮาร์ดแวร์ที่ระดับต่างๆ ในแอปพลิเคชัน

ดูเลเยอร์

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

เริ่มตั้งแต่ Android 3.0 (API ระดับ 11) คุณจะควบคุมวิธีและเวลาที่ควรใช้เลเยอร์ได้มากขึ้น ด้วยเมธอด View.setLayerType() API นี้ใช้เวลา 2 พารามิเตอร์: ประเภทเลเยอร์ที่คุณต้องการใช้ และ Paint ซึ่งไม่บังคับ ที่อธิบายวิธีการประกอบเลเยอร์ คุณสามารถใช้พารามิเตอร์ Paint เพื่อใช้ฟิลเตอร์สี โหมดผสานพิเศษ หรือความทึบแสงกับ มุมมองหนึ่งสามารถใช้เลเยอร์หนึ่งใน 3 ประเภทต่อไปนี้

• LAYER_TYPE_NONE: มุมมองจะแสดงผลตามปกติและไม่มีการสำรองข้อมูล จากบัฟเฟอร์นอกหน้าจอ นี่คือลักษณะการทำงานเริ่มต้น
• LAYER_TYPE_HARDWARE: มุมมองจะแสดงผลในฮาร์ดแวร์เป็น พื้นผิวฮาร์ดแวร์ หากแอปพลิเคชันมีการเร่งฮาร์ดแวร์ หากแอปพลิเคชันไม่ใช่ฮาร์ดแวร์ แบบเร่ง เลเยอร์ประเภทนี้จะทํางานเหมือนกับ LAYER_TYPE_SOFTWARE
• LAYER_TYPE_SOFTWARE: มุมมองจะแสดงผลในซอฟต์แวร์เป็น บิตแมป

ประเภทของเลเยอร์ที่คุณใช้จะขึ้นอยู่กับเป้าหมายของคุณ ดังนี้

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

ดูเลเยอร์และภาพเคลื่อนไหว

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

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

• alpha: เปลี่ยนความทึบแสงของเลเยอร์
• x y translationX translationY เปลี่ยนตำแหน่งของเลเยอร์
• scaleX, scaleY: เปลี่ยนขนาดของเลเยอร์
• rotation, rotationX, rotationY: เปลี่ยนแปลง การวางแนวของเลเยอร์ในพื้นที่ 3 มิติ
• pivotX, pivotY: เปลี่ยนต้นทางการเปลี่ยนรูปแบบของเลเยอร์

พร็อพเพอร์ตี้เหล่านี้เป็นชื่อที่ใช้เมื่อทำให้มุมมองเคลื่อนไหวด้วย ObjectAnimator หากคุณต้องการเข้าถึงคุณสมบัติเหล่านี้ ให้โทรหา Setter หรือ Getter ตัวอย่างเช่น หากต้องการแก้ไขพร็อพเพอร์ตี้อัลฟ่า ให้เรียก setAlpha() ข้อมูลโค้ดต่อไปนี้เป็นวิธีที่มีประสิทธิภาพมากที่สุด เพื่อหมุนมุมมองในมุมมอง 3 มิติรอบแกน Y โดยทำดังนี้

view.setLayerType(View.LAYER_TYPE_HARDWARE, null)
ObjectAnimator.ofFloat(view, "rotationY", 180f).start()

view.setLayerType(View.LAYER_TYPE_HARDWARE, null);
ObjectAnimator.ofFloat(view, "rotationY", 180).start();

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

view.setLayerType(View.LAYER_TYPE_HARDWARE, null)
ObjectAnimator.ofFloat(view, "rotationY", 180f).apply {
    addListener(object : AnimatorListenerAdapter() {
        override fun onAnimationEnd(animation: Animator) {
            view.setLayerType(View.LAYER_TYPE_NONE, null)
        }
    })
    start()
}

view.setLayerType(View.LAYER_TYPE_HARDWARE, null);
ObjectAnimator animator = ObjectAnimator.ofFloat(view, "rotationY", 180);
animator.addListener(new AnimatorListenerAdapter() {
    @Override
    public void onAnimationEnd(Animator animation) {
        view.setLayerType(View.LAYER_TYPE_NONE, null);
    }
});
animator.start();

ดูข้อมูลเพิ่มเติมเกี่ยวกับภาพเคลื่อนไหวของพร็อพเพอร์ตี้ได้ที่ภาพเคลื่อนไหวของพร็อพเพอร์ตี้

กลเม็ดเคล็ดลับ

การสลับไปใช้กราฟิก 2 มิติที่มีการเร่งความเร็วด้วยฮาร์ดแวร์สามารถเพิ่มประสิทธิภาพได้ในทันที แต่คุณ ยังควรออกแบบแอปพลิเคชันให้ใช้ GPU ได้อย่างมีประสิทธิภาพโดยทำตาม คำแนะนำ:

ลดจำนวนยอดดูในแอปพลิเคชัน

ยิ่งระบบวาดมุมมองได้มากเท่าใด ก็จะยิ่งช้าลงเท่านั้น รายการนี้มีผลกับซอฟต์แวร์ การแสดงผลด้วยไปป์ไลน์ การลดยอดดูเป็นวิธีที่ง่ายที่สุดวิธีหนึ่งในการเพิ่มประสิทธิภาพ UI

หลีกเลี่ยงการวาดทับ

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

ไม่สร้างวัตถุการแสดงผลในวิธีการวาด

ข้อผิดพลาดที่พบบ่อยคือการสร้าง Paint ใหม่หรือ Path ใหม่ทุกครั้งที่มีการเรียกใช้วิธีการแสดงผล วิธีนี้จะทำให้ถังขยะ ให้เรียกใช้บ่อยขึ้น รวมทั้งเลี่ยงการแคชและการเพิ่มประสิทธิภาพในฮาร์ดแวร์ด้วย ไปป์ไลน์

อย่าแก้ไขรูปร่างบ่อยเกินไป

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

อย่าแก้ไขบิตแมปบ่อยเกินไป

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

ใช้อัลฟ่าอย่างระมัดระวัง

เมื่อคุณทำให้มุมมองโปร่งแสงโดยใช้ setAlpha() AlphaAnimation หรือ ObjectAnimator แสดงในบัฟเฟอร์นอกหน้าจอ ซึ่งจะเพิ่มอัตราการส่งโฆษณาที่จำเป็นเป็น 2 เท่า เมื่อใช้อัลฟ่า ในมุมมองขนาดใหญ่มาก ให้พิจารณาตั้งค่าประเภทเลเยอร์ของมุมมองเป็น LAYER_TYPE_HARDWARE