ลำดับชั้นของประสิทธิภาพและมุมมอง

วิธีที่คุณจัดการลำดับชั้นของออบเจ็กต์ 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 อื่นๆ เฟรมเวิร์กจะดำเนินการตามลำดับต่อไปนี้

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

ยิ่งลำดับชั้นการแสดงผลมีหลายระดับมากเท่าใด ก็ยิ่งมีโอกาสที่จะส่งผลเสียต่อประสิทธิภาพมากขึ้นเท่านั้น

ดังที่กล่าวไว้ก่อนหน้านี้ โดยทั่วไปแล้ว 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

รูปที่ 1 เลือกตรวจสอบโค้ดใน Android Studio

ข้อมูลเกี่ยวกับรายการเลย์เอาต์ต่างๆ จะปรากฏในส่วน Android > Lint > ประสิทธิภาพ หากต้องการดูรายละเอียดเพิ่มเติม ให้คลิกแต่ละรายการเพื่อขยายและแสดงข้อมูลเพิ่มเติมในแผงด้านขวาของหน้าจอ รูปที่ 2 แสดงตัวอย่างข้อมูลที่ขยาย

รูปที่ 2 การดูข้อมูลเกี่ยวกับปัญหาที่เฉพาะเจาะจงซึ่งเครื่องมือ Lint ระบุ

การคลิกรายการจะแสดงปัญหาที่เกี่ยวข้องกับรายการนั้นในแผงด้านขวา

หากต้องการทำความเข้าใจเพิ่มเติมเกี่ยวกับหัวข้อและปัญหาที่เฉพาะเจาะจงในส่วนนี้ โปรดดูเอกสารประกอบของ 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 พร้อมฟีเจอร์เพิ่มเติมเพื่อช่วยสร้างเลย์เอาต์ที่เรียบง่ายและมีประสิทธิภาพมากขึ้น