วิธีที่คุณจัดการลำดับชั้นของออบเจ็กต์ View อาจส่งผลต่อประสิทธิภาพของแอปอย่างมาก หน้านี้อธิบายวิธีประเมินว่าลำดับชั้นการแสดงผลทำให้แอปทำงานช้าลงหรือไม่ และเสนอกลยุทธ์บางอย่างในการแก้ไขปัญหาที่อาจเกิดขึ้น
หน้านี้จะมุ่งเน้นที่การปรับปรุงเลย์เอาต์ที่อิงตาม View ดูข้อมูลเกี่ยวกับการปรับปรุงประสิทธิภาพของ Jetpack Compose ได้ที่ประสิทธิภาพของ Jetpack Compose
ประสิทธิภาพของเลย์เอาต์และการวัดผล
ไปป์ไลน์การแสดงผลประกอบด้วยระยะเลย์เอาต์และการวัด ซึ่งระบบจะจัดตำแหน่งรายการที่เกี่ยวข้องในลำดับชั้นการแสดงผลอย่างเหมาะสม ส่วนการวัดของขั้นตอนนี้จะกำหนดขนาดและขอบเขตของวัตถุ View รายการ ส่วนเลย์เอาต์จะกำหนดตำแหน่งบนหน้าจอเพื่อวางออบเจ็กต์ View
ทั้ง 2 ขั้นตอนของไปป์ไลน์นี้มีต้นทุนต่อการดูหรือเลย์เอาต์ที่ประมวลผลเล็กน้อย โดยส่วนใหญ่แล้ว ค่าใช้จ่ายนี้จะน้อยมากและไม่ส่งผลต่อประสิทธิภาพอย่างเห็นได้ชัด อย่างไรก็ตาม จำนวนอาจมากกว่านี้เมื่อแอปเพิ่มหรือนำออบเจ็กต์ View ออก เช่น เมื่อออบเจ็กต์ RecyclerView รีไซเคิลหรือนำออบเจ็กต์กลับมาใช้ใหม่ นอกจากนี้ ค่าใช้จ่ายอาจสูงขึ้นหากออบเจ็กต์ View ต้องพิจารณาการปรับขนาดเพื่อให้เป็นไปตามข้อจำกัด ตัวอย่างเช่น หากแอปเรียกใช้
SetText()
ในออบเจ็กต์ View ที่ตัดข้อความ View อาจต้องปรับขนาด
หากกรณีเช่นนี้ใช้เวลานานเกินไป ก็อาจทำให้เฟรมไม่สามารถแสดงผลภายใน 16 มิลลิวินาทีที่อนุญาต ซึ่งอาจทำให้เฟรมหลุดและทำให้ภาพเคลื่อนไหวไม่ราบรื่น
เนื่องจากคุณไม่สามารถย้ายการดำเนินการเหล่านี้ไปยังเทรดผู้ปฏิบัติงานได้ แอปจึงต้องประมวลผลการดำเนินการเหล่านี้ในเทรดหลัก ดังนั้นจึงควรเพิ่มประสิทธิภาพการดำเนินการเหล่านี้เพื่อให้ใช้เวลาน้อยที่สุด
จัดการเลย์เอาต์ที่ซับซ้อน
เลย์เอาต์ของ Android ช่วยให้คุณฝังออบเจ็กต์ UI ในลำดับชั้นการแสดงผลได้ การฝังนี้อาจทำให้เกิดค่าใช้จ่ายเกี่ยวกับเลย์เอาต์ด้วย เมื่อแอปประมวลผลออบเจ็กต์สำหรับเลย์เอาต์ แอปจะดำเนินการกระบวนการเดียวกันกับองค์ประกอบย่อยทั้งหมดของเลย์เอาต์ด้วย
สำหรับเลย์เอาต์ที่ซับซ้อน บางครั้งค่าใช้จ่ายจะเกิดขึ้นเฉพาะในครั้งแรกที่ระบบคำนวณเลย์เอาต์เท่านั้น ตัวอย่างเช่น เมื่อแอปรีไซเคิลรายการที่ซับซ้อนในออบเจ็กต์ RecyclerView ระบบจะต้องจัดวางออบเจ็กต์ทั้งหมด ในอีกตัวอย่างหนึ่ง การเปลี่ยนแปลงเล็กน้อยอาจส่งผลต่อห่วงโซ่ไปยังระดับบนจนกว่าจะถึงออบเจ็กต์ที่ไม่ส่งผลต่อขนาดของระดับบน
สาเหตุที่พบบ่อยที่ทำให้เลย์เอาต์ใช้เวลานานคือเมื่อลำดับชั้นของออบเจ็กต์ View ซ้อนกันอยู่ภายในออบเจ็กต์อื่น ออบเจ็กต์เลย์เอาต์ที่ฝังแต่ละรายการจะเพิ่มต้นทุนให้กับระยะเลย์เอาต์ ยิ่งลำดับชั้นแบนราบมากเท่าใด ขั้นตอนเลย์เอาต์ก็จะใช้เวลาในการดำเนินการเสร็จสมบูรณ์น้อยลงเท่านั้น
เราขอแนะนำให้ใช้เครื่องมือแก้ไขเลย์เอาต์เพื่อสร้าง ConstraintLayout แทน RelativeLayout หรือ LinearLayout เนื่องจากโดยทั่วไปแล้วจะมีประสิทธิภาพมากกว่าและลดการฝังเลย์เอาต์ อย่างไรก็ตาม สำหรับเลย์เอาต์แบบง่ายที่สามารถทำได้โดยใช้ FrameLayout เราขอแนะนำให้ใช้ FrameLayout
หากใช้คลาส RelativeLayout คุณอาจได้ผลลัพธ์เดียวกันโดยมีค่าใช้จ่ายต่ำกว่าด้วยการใช้มุมมอง LinearLayout ที่ซ้อนกันและไม่มีการถ่วงน้ำหนักแทน อย่างไรก็ตาม หากคุณใช้มุมมอง LinearLayout ที่ซ้อนกันและมีการถ่วงน้ำหนัก ต้นทุนเลย์เอาต์จะสูงขึ้นมากเนื่องจากต้องใช้การส่งผ่านเลย์เอาต์หลายครั้ง ดังที่อธิบายไว้ในส่วนถัดไป
นอกจากนี้ เราขอแนะนำให้ใช้ RecyclerView แทน ListView เนื่องจากสามารถรีไซเคิลเลย์เอาต์ของรายการแต่ละรายการได้ ซึ่งมีประสิทธิภาพมากกว่าและปรับปรุงประสิทธิภาพการเลื่อนได้
การเก็บภาษีซ้อน
โดยปกติแล้ว เฟรมเวิร์กจะเรียกใช้เลย์เอาต์หรือขั้นตอนการวัดค่าในการส่งครั้งเดียว อย่างไรก็ตาม ในกรณีที่เลย์เอาต์มีความซับซ้อน เฟรมเวิร์กอาจต้องทำซ้ำหลายครั้งในส่วนของลำดับชั้นที่ต้องใช้การส่งผ่านหลายครั้งเพื่อแก้ไขก่อนที่จะจัดตำแหน่งองค์ประกอบในท้ายที่สุด การต้องทำซ้ำการจัดวางและการวัดมากกว่า 1 ครั้งเรียกว่าการเก็บภาษีซ้ำซ้อน
ตัวอย่างเช่น เมื่อคุณใช้คอนเทนเนอร์ RelativeLayout ซึ่งช่วยให้คุณวางตำแหน่งออบเจ็กต์ View โดยอิงตามตำแหน่งของออบเจ็กต์ View อื่นๆ เฟรมเวิร์กจะดำเนินการตามลำดับต่อไปนี้
- ดำเนินการส่งผ่านเลย์เอาต์และการวัด ซึ่งในระหว่างนั้นเฟรมเวิร์กจะคำนวณตำแหน่งและขนาดของออบเจ็กต์ย่อยแต่ละรายการตามคำขอของออบเจ็กต์ย่อยแต่ละรายการ
- ใช้ข้อมูลนี้โดยคำนึงถึงน้ำหนักของออบเจ็กต์เพื่อหาตำแหน่งที่เหมาะสมของมุมมองที่สัมพันธ์กัน
- ดำเนินการส่งผ่านเลย์เอาต์ครั้งที่ 2 เพื่อสรุปตำแหน่งของออบเจ็กต์
- ย้ายไปยังขั้นตอนถัดไปของกระบวนการแสดงผล
ยิ่งลำดับชั้นการแสดงผลมีหลายระดับมากเท่าใด ก็ยิ่งมีโอกาสที่จะส่งผลเสียต่อประสิทธิภาพมากขึ้นเท่านั้น
ดังที่กล่าวไว้ก่อนหน้านี้ โดยทั่วไปแล้ว ConstraintLayout จะมีประสิทธิภาพมากกว่าเลย์เอาต์อื่นๆ ยกเว้น FrameLayout ซึ่งมีแนวโน้มที่จะเกิดการส่งผ่านเลย์เอาต์หลายครั้งน้อยกว่า และในหลายๆ กรณีก็ไม่จำเป็นต้องฝังเลย์เอาต์
คอนเทนเนอร์อื่นๆ นอกเหนือจาก RelativeLayout อาจเพิ่มการเก็บภาษีซ้อนด้วย เช่น
- มุมมอง
LinearLayoutอาจส่งผลให้เกิดการส่งผ่านเลย์เอาต์และการวัดผลซ้ำซ้อนหากคุณทำให้เป็นแนวนอน การส่งผ่านเลย์เอาต์และการวัดผลซ้ำอาจเกิดขึ้นในแนวตั้งด้วยหากคุณเพิ่มmeasureWithLargestChildซึ่งในกรณีนี้เฟรมเวิร์กอาจต้องส่งผ่านครั้งที่ 2 เพื่อแก้ไขขนาดที่เหมาะสมของออบเจ็กต์ GridLayoutยังอนุญาตให้ใช้การจัดตำแหน่งแบบสัมพัทธ์ด้วย แต่โดยปกติแล้วจะหลีกเลี่ยงการเก็บภาษีซ้อนโดยการประมวลผลความสัมพันธ์เชิงตำแหน่งระหว่างหน้าจอสำหรับเด็กไว้ล่วงหน้า อย่างไรก็ตาม หากเลย์เอาต์ใช้น้ำหนักหรือเติมด้วยคลาสGravityประโยชน์ของการประมวลผลล่วงหน้าจะหายไป และเฟรมเวิร์กอาจต้องทำการส่งหลายครั้งหากคอนเทนเนอร์เป็นRelativeLayout
การส่งผ่านเลย์เอาต์และการวัดหลายรายการไม่จำเป็นต้องเป็นภาระด้านประสิทธิภาพเสมอไป แต่ก็อาจกลายเป็นภาระได้หากอยู่ในตำแหน่งที่ไม่ถูกต้อง โปรดระมัดระวังในสถานการณ์ที่คอนเทนเนอร์ของคุณมีเงื่อนไขอย่างใดอย่างหนึ่งต่อไปนี้
- ซึ่งเป็นองค์ประกอบรูทในลำดับชั้นการแสดงผล
- มีลำดับชั้นการแสดงผลที่ลึกอยู่ด้านล่าง
- มีหลายอินสแตนซ์ที่แสดงบนหน้าจอ คล้ายกับออบเจ็กต์ย่อยในออบเจ็กต์
ListView
วิเคราะห์ปัญหาเกี่ยวกับลำดับชั้นการแสดงผล
ประสิทธิภาพของเลย์เอาต์เป็นปัญหาที่ซับซ้อนและมีหลายแง่มุม เครื่องมือต่อไปนี้จะช่วยคุณระบุจุดที่เกิดคอขวดด้านประสิทธิภาพได้ เครื่องมือบางอย่างอาจให้ข้อมูลที่ชัดเจนน้อยกว่า แต่ก็ให้คำแนะนำที่เป็นประโยชน์ได้
Perfetto
Perfetto เป็นเครื่องมือที่ให้ข้อมูลเกี่ยวกับประสิทธิภาพ คุณเปิดการติดตาม Android ได้ใน Perfetto UI
การแสดงผล GPU ตามโปรไฟล์
เครื่องมือProfile GPU renderingในอุปกรณ์ซึ่งพร้อมใช้งานในอุปกรณ์ที่ขับเคลื่อนโดย Android 6.0 (ระดับ API 23) ขึ้นไปจะให้ข้อมูลที่ชัดเจนเกี่ยวกับจุดคอขวดด้านประสิทธิภาพ เครื่องมือนี้ช่วยให้คุณเห็นระยะเวลาที่ใช้ในขั้นตอนการจัดวางและวัดผลสำหรับการแสดงผลแต่ละเฟรม ข้อมูลนี้จะช่วยคุณวิเคราะห์ปัญหาด้านประสิทธิภาพของรันไทม์ และช่วยระบุปัญหาเกี่ยวกับเลย์เอาต์และการวัดผลที่คุณต้องแก้ไข
ในการแสดงข้อมูลที่บันทึกไว้เป็นภาพกราฟิก การแสดงผล GPU ของโปรไฟล์จะใช้สีน้ำเงินเพื่อแสดงเวลาของเลย์เอาต์ ดูข้อมูลเพิ่มเติมเกี่ยวกับวิธีใช้เครื่องมือนี้ได้ที่ความเร็วในการแสดงผล GPU ของโปรไฟล์
Lint
เครื่องมือ Lint ของ Android Studio ช่วยให้คุณทราบถึงความไม่มีประสิทธิภาพในลำดับชั้นการแสดงผลได้ หากต้องการใช้เครื่องมือนี้ ให้เลือกวิเคราะห์ > ตรวจสอบโค้ด ดังที่แสดงในรูปที่ 1
ข้อมูลเกี่ยวกับรายการเลย์เอาต์ต่างๆ จะปรากฏในส่วน Android > Lint > ประสิทธิภาพ หากต้องการดูรายละเอียดเพิ่มเติม ให้คลิกแต่ละรายการเพื่อขยายและแสดงข้อมูลเพิ่มเติมในแผงด้านขวาของหน้าจอ รูปที่ 2 แสดงตัวอย่างข้อมูลที่ขยาย
การคลิกรายการจะแสดงปัญหาที่เกี่ยวข้องกับรายการนั้นในแผงด้านขวา
หากต้องการทำความเข้าใจเพิ่มเติมเกี่ยวกับหัวข้อและปัญหาที่เฉพาะเจาะจงในส่วนนี้ โปรดดูเอกสารประกอบของ Lint
เครื่องมือตรวจสอบเลย์เอาต์
เครื่องมือตรวจสอบเลย์เอาต์ของ Android Studio จะแสดงภาพลำดับชั้นการแสดงผลของแอป ซึ่งเป็นวิธีที่ดีในการไปยังส่วนต่างๆ ของลำดับชั้นของแอป โดยแสดงภาพที่ชัดเจนของเชนระดับบนสุดของมุมมองหนึ่งๆ และช่วยให้คุณตรวจสอบเลย์เอาต์ที่แอปสร้างขึ้นได้
มุมมองที่เครื่องมือตรวจสอบเลย์เอาต์แสดงยังช่วยระบุปัญหาด้านประสิทธิภาพที่เกิดจากการเก็บภาษีซ้อนได้ด้วย นอกจากนี้ยังช่วยให้คุณระบุเชนที่ลึกของเลย์เอาต์ที่ซ้อนกัน หรือพื้นที่เลย์เอาต์ที่มีองค์ประกอบย่อยที่ซ้อนกันจำนวนมาก ซึ่งอาจเป็นสาเหตุของต้นทุนด้านประสิทธิภาพ ในกรณีเหล่านี้ ขั้นตอนการจัดวางและการวัดผลอาจมีค่าใช้จ่ายสูงและส่งผลให้เกิดปัญหาด้านประสิทธิภาพ
ดูข้อมูลเพิ่มเติมได้ที่แก้ไขข้อบกพร่องของเลย์เอาต์ด้วยเครื่องมือตรวจสอบเลย์เอาต์และการตรวจสอบเลย์เอาต์
แก้ปัญหาเกี่ยวกับลำดับชั้นการแสดงผล
แนวคิดพื้นฐานเบื้องหลังการแก้ปัญหาด้านประสิทธิภาพที่เกิดจากลำดับชั้นการแสดงผลอาจทำได้ยากในทางปฏิบัติ การป้องกันไม่ให้ลำดับชั้นการแสดงผลส่งผลเสียต่อประสิทธิภาพประกอบด้วยการทำให้ลำดับชั้นการแสดงผลแบนราบและลดการเก็บภาษีซ้ำซ้อน ส่วนนี้จะพูดถึงกลยุทธ์ในการบรรลุเป้าหมายเหล่านี้
นำเลย์เอาต์ที่ซ้อนกันซ้ำซ้อนออก
ConstraintLayout
เป็นไลบรารี Jetpack ที่มีกลไกต่างๆ มากมายสำหรับการจัดตำแหน่งมุมมองภายในเลย์เอาต์ ซึ่งจะช่วยลดความจำเป็นในการฝัง ConstaintLayout หนึ่งรายการและช่วยลดความซับซ้อนของลำดับชั้นการแสดงผลได้ โดยปกติแล้ว การทำให้ลำดับชั้นแบนราบโดยใช้ ConstraintLayout จะง่ายกว่าเมื่อเทียบกับเลย์เอาต์ประเภทอื่นๆ
นักพัฒนาแอปมักใช้เลย์เอาต์ที่ซ้อนกันมากกว่าที่จำเป็น เช่น คอนเทนเนอร์ RelativeLayout อาจมีรายการย่อยรายการเดียวซึ่งเป็นคอนเทนเนอร์ RelativeLayout ด้วย การฝังนี้ซ้ำซ้อนและเพิ่มต้นทุนที่ไม่จำเป็นให้กับลำดับชั้นการแสดงผล Lint สามารถแจ้งปัญหานี้ให้คุณทราบได้ ซึ่งจะช่วยลดเวลาในการแก้ไขข้อบกพร่อง
ใช้การผสานหรือรวม
สาเหตุที่พบบ่อยของเลย์เอาต์ที่ซ้อนกันซ้ำซ้อนคือแท็ก <include> ตัวอย่างเช่น คุณอาจกำหนดเลย์เอาต์ที่นำกลับมาใช้ใหม่ได้ดังนี้
<LinearLayout> <!-- some stuff here --> </LinearLayout>
จากนั้นคุณอาจเพิ่มแท็ก <include> เพื่อเพิ่มรายการต่อไปนี้ลงในคอนเทนเนอร์หลัก
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:orientation="vertical" android:layout_width="match_parent" android:layout_height="match_parent" android:background="@color/app_bg" android:gravity="center_horizontal"> <include layout="@layout/titlebar"/> <TextView android:layout_width="match_parent" android:layout_height="wrap_content" android:text="@string/hello" android:padding="10dp" /> ... </LinearLayout>
การรวมก่อนหน้านี้จะฝังเลย์เอาต์แรกไว้ในเลย์เอาต์ที่ 2 โดยไม่จำเป็น
แท็ก <merge> ช่วยป้องกันปัญหานี้ได้ ดูข้อมูลเกี่ยวกับแท็กนี้ได้ที่ใช้แท็ก <merge>
ใช้เลย์เอาต์ที่ประหยัดกว่า
คุณอาจปรับรูปแบบเลย์เอาต์ที่มีอยู่ไม่ได้เพื่อให้ไม่มีเลย์เอาต์ที่ซ้ำซ้อน ในบางกรณี วิธีแก้ปัญหาเดียวอาจเป็นการทำให้ลำดับชั้นแบนราบโดยเปลี่ยนไปใช้เลย์เอาต์ประเภทอื่นโดยสิ้นเชิง
ตัวอย่างเช่น คุณอาจพบว่า TableLayout มีฟังก์ชันการทำงานเหมือนกับเลย์เอาต์ที่ซับซ้อนกว่าซึ่งมีการขึ้นต่อกันตามตำแหน่งหลายรายการ ไลบรารี Jetpack
ConstraintLayout
มีฟังก์ชันการทำงานคล้ายกับ RelativeLayout พร้อมฟีเจอร์เพิ่มเติมเพื่อช่วยสร้างเลย์เอาต์ที่เรียบง่ายและมีประสิทธิภาพมากขึ้น