การทำโปรไฟล์ตามทริกเกอร์

ProfilingManager รองรับการบันทึกโปรไฟล์ตามทริกเกอร์ของระบบ ระบบจะจัดการกระบวนการบันทึกและส่งโปรไฟล์ที่ได้ไปยังแอปของคุณ

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

บันทึกข้อมูลย้อนหลัง

ทริกเกอร์หลายรายการต้องวิเคราะห์ข้อมูลย้อนหลังที่นำไปสู่เหตุการณ์ ทริกเกอร์มักเป็นผลมาจากปัญหามากกว่าสาเหตุหลัก หากคุณเริ่มโปรไฟล์หลังจากทริกเกอร์เกิดขึ้นแล้ว สาเหตุที่แท้จริงอาจหายไปแล้ว

เช่น การดำเนินการที่ใช้เวลานานในเธรด UI จะทำให้เกิดข้อผิดพลาดแอปพลิเคชัน ไม่ตอบสนอง (ANR) เมื่อระบบตรวจพบ ANR และส่งสัญญาณไปยังแอป การดำเนินการอาจเสร็จสิ้นแล้ว การเริ่มสร้างโปรไฟล์ใน เวลานั้นจะทำให้พลาดการบล็อกจริง

การคาดการณ์เวลาที่แน่นอนของการทริกเกอร์บางอย่างเป็นไปไม่ได้ จึงทำให้ไม่สามารถ เริ่มโปรไฟล์ด้วยตนเองล่วงหน้าได้

เหตุผลที่ควรใช้การจับภาพตามทริกเกอร์

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

• แก้ไขข้อบกพร่องด้านประสิทธิภาพ: วินิจฉัย ANR, หน่วยความจำรั่ว และปัญหาด้านความเสถียรอื่นๆ
• เพิ่มประสิทธิภาพเส้นทางของผู้ใช้ที่สำคัญ: วิเคราะห์และปรับปรุงโฟลว์ เช่น การเริ่มต้นแอป
• ทําความเข้าใจพฤติกรรมของผู้ใช้: รับข้อมูลเชิงลึกเกี่ยวกับเหตุการณ์ เช่น ผู้ใช้เริ่มออกจากแอป

ตั้งค่าทริกเกอร์

โค้ดต่อไปนี้แสดงวิธีลงทะเบียนทริกเกอร์ TRIGGER_TYPE_APP_FULLY_DRAWN และใช้การจำกัดอัตรากับทริกเกอร์

fun recordWithTrigger() {
    val profilingManager = applicationContext.getSystemService(ProfilingManager::class.java)

    val triggers = ArrayList<ProfilingTrigger>()

    val triggerBuilder = ProfilingTrigger.Builder(ProfilingTrigger.TRIGGER_TYPE_APP_FULLY_DRAWN)
        .setRateLimitingPeriodHours(1)

    triggers.add(triggerBuilder.build())

    val mainExecutor: Executor = Executors.newSingleThreadExecutor()

    val resultCallback = Consumer<ProfilingResult> { profilingResult ->
        if (profilingResult.errorCode == ProfilingResult.ERROR_NONE) {
            Log.d(
                "ProfileTest",
                "Received profiling result file=" + profilingResult.resultFilePath
            )
            setupProfileUploadWorker(profilingResult.resultFilePath)
        } else {
            Log.e(
                "ProfileTest",
                "Profiling failed errorcode=" + profilingResult.errorCode + " errormsg=" + profilingResult.errorMessage
            )
        }
    }

    profilingManager.registerForAllProfilingResults(mainExecutor, resultCallback)
    profilingManager.addProfilingTriggers(triggers)
ProfilingManagerKotlinSnippets.kt

public void recordWithTrigger() {
  ProfilingManager profilingManager = getApplicationContext().getSystemService(
      ProfilingManager.class);
  List<ProfilingTrigger> triggers = new ArrayList<>();
  ProfilingTrigger.Builder triggerBuilder = new ProfilingTrigger.Builder(
      ProfilingTrigger.TRIGGER_TYPE_APP_FULLY_DRAWN);
  triggerBuilder.setRateLimitingPeriodHours(1);
  triggers.add(triggerBuilder.build());

  Executor mainExecutor = Executors.newSingleThreadExecutor();
  Consumer<ProfilingResult> resultCallback =
      new Consumer<ProfilingResult>() {
        @Override
        public void accept(ProfilingResult profilingResult) {
          if (profilingResult.getErrorCode() == ProfilingResult.ERROR_NONE) {
            Log.d(
                "ProfileTest",
                "Received profiling result file=" + profilingResult.getResultFilePath());
            setupProfileUploadWorker(profilingResult.getResultFilePath());
          } else {
            Log.e(
                "ProfileTest",
                "Profiling failed errorcode="
                    + profilingResult.getErrorCode()
                    + " errormsg="
                    + profilingResult.getErrorMessage());
          }
        }
      };
  profilingManager.registerForAllProfilingResults(mainExecutor, resultCallback);
  profilingManager.addProfilingTriggers(triggers);
ProfilingManagerJavaSnippets.java

โค้ดจะทำตามขั้นตอนต่อไปนี้

1. รับผู้จัดการ: เรียกข้อมูลบริการ ProfilingManager
2. กำหนดทริกเกอร์: สร้าง ProfilingTrigger สำหรับ TRIGGER_TYPE_APP_FULLY_DRAWN เหตุการณ์นี้จะเกิดขึ้นเมื่อแอปรายงานว่า แอปเริ่มต้นเสร็จสมบูรณ์และพร้อมใช้งานแล้ว
3. ตั้งค่าขีดจำกัดอัตรา: ใช้ขีดจำกัดอัตรา 1 ชั่วโมงกับทริกเกอร์นี้โดยเฉพาะ (setRateLimitingPeriodHours(1)) ซึ่งจะป้องกันไม่ให้แอปบันทึกโปรไฟล์การเริ่มต้นมากกว่า 1 รายการต่อชั่วโมง
4. Register listener: เรียกใช้ registerForAllProfilingResults เพื่อกำหนด การเรียกกลับที่จัดการผลลัพธ์ การเรียกกลับนี้จะได้รับเส้นทางของโปรไฟล์ที่บันทึกผ่าน getResultFilePath()
5. เพิ่มทริกเกอร์: ลงทะเบียนรายการทริกเกอร์กับ ProfilingManager โดยใช้ addProfilingTriggers
6. เริ่มเหตุการณ์: เรียกใช้ reportFullyDrawn() ซึ่งจะปล่อยเหตุการณ์ TRIGGER_TYPE_APP_FULLY_DRAWN ไปยังระบบเพื่อทริกเกอร์การรวบรวมโปรไฟล์ โดยสมมติว่ามีการเรียกใช้การติดตามเบื้องหลังของระบบและมีโควต้าตัวจำกัดอัตรา ขั้นตอนนี้ไม่บังคับ แต่จะแสดงโฟลว์ตั้งแต่ต้นจนจบ เนื่องจากแอปต้องเรียกใช้ reportFullyDrawn() สำหรับทริกเกอร์นี้

ดึงข้อมูลการติดตาม

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

profile_trigger_<profile_type_code>_<datetime>.<profile-type-name>

คุณดึงไฟล์ได้โดยใช้ ADB ตัวอย่างเช่น หากต้องการดึงข้อมูลการติดตามระบบที่บันทึกด้วยโค้ดตัวอย่างโดยใช้ ADB อาจมีลักษณะดังนี้

adb pull /data/user/0/com.example.sampleapp/files/profiling/profile_trigger_1_2025-05-06-14-12-40.perfetto-trace

ดูรายละเอียดเกี่ยวกับการแสดงภาพร่องรอยเหล่านี้ได้ที่เรียกข้อมูลการทำโปรไฟล์และวิเคราะห์ข้อมูล

วิธีการทำงานของการตรวจหาการสัมผัสในเบื้องหลัง

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

เมื่อบันทึกโปรไฟล์แล้ว ระบบจะแจ้งเตือนแอปของคุณโดยใช้การเรียกกลับ ที่ระบุไว้ใน registerForAllProfilingResults การเรียกกลับนี้จะระบุเส้นทางไปยัง โปรไฟล์ที่บันทึกไว้ ซึ่งเข้าถึงได้โดยการเรียก ProfilingResult#getResultFilePath()

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

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

ใช้การจำกัดอัตราเฉพาะทริกเกอร์

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

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

แก้ไขข้อบกพร่องของทริกเกอร์ในเครื่อง

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

adb shell device_config put profiling_testing system_triggered_profiling.testing_package_name <com.example.myapp>

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

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