การติดตามการเรียบเรียง

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

Android รองรับการติดตาม 2 ระดับ ได้แก่ System Tracing และการติดตามเมธอด

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

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

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

การติดตามการคอมโพสิชันจะแสดงฟังก์ชันที่ประกอบกันได้ภายในการติดตามของระบบ ฟีเจอร์นี้ช่วยให้คุณได้รับผลกระทบต่ำจาก System Tracing โดยมีรายละเอียดระดับร่องรอยเมธอดในองค์ประกอบ

การตั้งค่าการติดตามการเขียน

หากต้องการลองใช้การติดตามการจัดองค์ประกอบใหม่ในโปรเจ็กต์ คุณต้องอัปเดตเป็นเวอร์ชันต่อไปนี้เป็นอย่างน้อย

  • Android Studio Flamingo
  • Compose UI: 1.3.0
  • คอมไพเลอร์ Compose: 1.3.0

อุปกรณ์หรือโปรแกรมจำลองที่คุณเรียกใช้การติดตามต้องมีระดับ API ขั้นต่ำที่ 30 ด้วย

นอกจากนี้ คุณต้องเพิ่มทรัพยากร Dependency ใหม่ในการติดตามรันไทม์ของ Compose ดังนี้

implementation("androidx.compose.runtime:runtime-tracing:1.12.1")

หากใช้ Compose BOM คุณไม่จำเป็นต้องระบุเวอร์ชัน ดังนี้

val composeBom = platform("androidx.compose:compose-bom:2026.09.00")
implementation(composeBom)
// ...

// dependency without a version
implementation("androidx.compose.runtime:runtime-tracing")

เมื่อใช้ทรัพยากร Dependency นี้ เมื่อคุณติดตามระบบที่มีการจัดองค์ประกอบใหม่ คุณจะเห็นฟังก์ชันที่ประกอบกันได้โดยอัตโนมัติ

บันทึกการติดตามของระบบ

หากต้องการติดตามของระบบและดูการติดตามการจัดองค์ประกอบใหม่แบบใหม่ ให้ทำตามขั้นตอนต่อไปนี้

  1. เปิดเครื่องมือวิเคราะห์โดยทำดังนี้

    Android Studio - เริ่มสร้างโปรไฟล์
    รูปที่ 2 Android Studio - เริ่มการทำโปรไฟล์
  2. คลิกไทม์ไลน์ CPU

    Android Studio Profiler - ไทม์ไลน์ CPU
    รูปที่ 3 Android Studio Profiler - ไทม์ไลน์ CPU
  3. ไปยัง UI ที่ต้องการติดตามในแอป แล้วเลือกการติดตามของระบบและบันทึก

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

    ตัวอย่างการแสดงภาพการติดตามของระบบใน Android Studio
    รูปที่ 5 การติดตามของระบบ

    การดับเบิลคลิกที่ Composable ในแผนภูมิจะนำคุณไปยังซอร์สโค้ดของ Composable นั้น

  5. นอกจากนี้ คุณยังดู Composable ในแผนภูมิ Flame Chart พร้อมกับไฟล์และหมายเลขบรรทัดได้ด้วย

    ตัวอย่างแผนภูมิ Flame Chart ที่แสดงฟังก์ชันที่ประกอบกันได้
    รูปที่ 6 แผนภูมิ Flame Chart

ข้อควรระวัง

เมื่อใช้การติดตามการคอมโพสิชัน โปรดพิจารณาข้อควรระวังต่อไปนี้เกี่ยวกับขนาดและประสิทธิภาพของ APK

ค่าใช้จ่ายเพิ่มเติมเกี่ยวกับขนาด APK

แม้ว่าเราจะพยายามลดค่าใช้จ่ายเพิ่มเติมของฟีเจอร์นี้ให้ได้มากที่สุด แต่ขนาด APK ของแอป Compose ก็เพิ่มขึ้นเนื่องจากสตริงการติดตามที่คอมไพเลอร์ Compose ฝังไว้ใน APK ขนาดที่เพิ่มขึ้นนี้อาจค่อนข้างเล็กหากแอปไม่ได้ใช้ Compose มากนัก หรืออาจมีขนาดใหญ่ขึ้นสำหรับแอปที่ใช้ Compose เต็มรูปแบบ สตริงการติดตามเหล่านี้ยังไม่ถูกสร้างความสับสนเพิ่มเติมเพื่อให้ปรากฏในเครื่องมือการติดตามได้ ดังที่แสดงไว้ก่อนหน้านี้ คอมไพเลอร์ Compose จะแทรกข้อมูลดังกล่าวลงในแอปทั้งหมด โดยเริ่มตั้งแต่เวอร์ชัน 1.3.0

คุณนำสตริงการติดตามออกในบิลด์เวอร์ชันที่ใช้งานจริงได้โดยเพิ่มกฎ Proguard ต่อไปนี้

-assumenosideeffects public class androidx.compose.runtime.ComposerKt {

   boolean isTraceInProgress();

   void traceEventStart(int,int,int,java.lang.String);

   void traceEventStart(int,java.lang.String);

   void traceEventEnd();

}

ฟังก์ชันเหล่านี้อาจเปลี่ยนแปลงในอนาคต แต่เราจะระบุการเปลี่ยนแปลงใดๆ ไว้ในบันทึกประจำรุ่นของ Compose

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

เวลาที่ถูกต้อง

เพื่อให้การทำโปรไฟล์แม่นยำ เช่นเดียวกับการทดสอบประสิทธิภาพ คุณต้องทำให้แอปprofileableและnon-debuggableเป็นไปตามแอปพลิเคชันที่ทำโปรไฟล์ได้

บันทึกการติดตามจากเทอร์มินัล

คุณสามารถบันทึกการติดตามการจัดองค์ประกอบจากเทอร์มินัลได้ โดยคุณจะต้องทำตามขั้นตอนที่ Android Studio มักจะทำโดยอัตโนมัติ

เพิ่มทรัพยากร Dependency

ก่อนอื่น ให้เพิ่มทรัพยากร Dependency เพิ่มเติมลงในแอป

implementation("androidx.tracing:tracing-perfetto:1.0.0")
implementation("androidx.tracing:tracing-perfetto-binary:1.0.0")

สร้างคำสั่งบันทึก

  1. สร้างคำสั่งบันทึกโดยใช้ Perfetto
  2. เพิ่มส่วนแหล่งข้อมูล track_event ด้วยตนเองตามตัวอย่างต่อไปนี้

    adb shell perfetto \
      -c - --txt \
      -o /data/misc/perfetto-traces/trace \
    <<EOF
    buffers: {
        size_kb: 63488
        fill_policy: RING_BUFFER
    }
    buffers: {
        size_kb: 2048
        fill_policy: RING_BUFFER
    }
    data_sources: {
        config {
            name: "track_event"
        }
    }
    duration_ms: 10000
    flush_period_ms: 30000
    incremental_state_config {
        clear_period_ms: 5000
    }
    EOF

บันทึกการติดตาม

  1. เปิดแอปและเตรียมส่วนที่ต้องการติดตาม
  2. เปิดใช้การติดตามในแอปโดยการออกอากาศ

    # set app package variable, e.g. com.google.samples.apps.nowinandroid.debug
    # can be found through `adb shell ps -ef` or `adb shell cmd package list packages`
    package=<your app process>
    
    # issue a broadcast to enable tracing
    adb shell am broadcast \
    -a androidx.tracing.perfetto.action.ENABLE_TRACING \
    $package/androidx.tracing.perfetto.TracingReceiver
    
  3. เริ่มคำสั่งการบันทึกที่คุณสร้างไว้ก่อนหน้านี้

เปิดการติดตาม

  1. adb pull <location> การติดตามจากอุปกรณ์ (ตำแหน่งที่ระบุในคำสั่งบันทึก)

  2. เปิดใน Perfetto

บันทึกการติดตามด้วย Jetpack Macrobenchmark

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

  1. เพิ่มทรัพยากร Dependency เพิ่มเติมเหล่านี้ลงในโมดูลทดสอบ Macrobenchmark

    implementation("androidx.tracing:tracing-perfetto:1.0.0")
    implementation("androidx.tracing:tracing-perfetto-binary:1.0.0")
    
  2. เพิ่มอาร์กิวเมนต์การวัดคุม androidx.benchmark.fullTracing.enable=true ก่อนเรียกใช้การเปรียบเทียบ ดูข้อมูลเพิ่มเติมเกี่ยวกับอาร์กิวเมนต์การวัดคุม Macrobenchmark ได้ที่อาร์กิวเมนต์การวัดคุม Macrobenchmark

ความคิดเห็น

เรายินดีรับฟังความคิดเห็นของคุณเกี่ยวกับฟีเจอร์นี้ ข้อบกพร่องที่คุณพบ และคำขอที่คุณมี คุณส่งความคิดเห็นถึงเราได้โดยใช้Issue Tracker