แก้ไขข้อบกพร่องของแอป

Android Studio มีโปรแกรมแก้ไขข้อบกพร่องที่ช่วยให้คุณทำสิ่งต่อไปนี้และอื่นๆ ได้

• เลือกอุปกรณ์ที่จะแก้ไขข้อบกพร่องของแอป
• ตั้งค่าเบรกพอยท์ในโค้ด Java, Kotlin และ C/C++
• ตรวจสอบตัวแปรและประเมินนิพจน์ขณะรันไทม์

หน้านี้มีคำแนะนำสำหรับการดำเนินการแก้ไขข้อบกพร่องพื้นฐาน ดูเอกสารประกอบเพิ่มเติมได้ในเอกสารการแก้ไขข้อบกพร่องของ IntelliJ IDEA

เปิดใช้การแก้ไขข้อบกพร่อง

ก่อนที่จะเริ่มแก้ไขข้อบกพร่อง ให้ทำดังนี้

เปิดใช้การแก้ไขข้อบกพร่องในอุปกรณ์

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

เรียกใช้ตัวแปรของบิลด์ที่แก้ไขข้อบกพร่องได้

ใช้ตัวแปรบิลด์ที่มี debuggable true (isDebuggable = true ในสคริปต์ Kotlin) ในการกำหนดค่าบิลด์

โดยปกติแล้ว คุณสามารถเลือกตัวแปร "แก้ไขข้อบกพร่อง" เริ่มต้นที่รวมอยู่ในโปรเจ็กต์ Android Studio ทั้งหมด แม้ว่าจะไม่เห็นตัวแปรดังกล่าวในไฟล์ build.gradle ก็ตาม อย่างไรก็ตาม หากคุณกำหนดประเภทบิลด์ใหม่ที่ควรแก้ไขข้อบกพร่องได้ คุณต้องเพิ่ม debuggable true ลงในประเภทบิลด์ดังนี้

Groovy

android {
    buildTypes {
        customDebugType {
            debuggable true
            ...
        }
    }
}

Kotlin

android {
    buildTypes {
        create("customDebugType") {
            isDebuggable = true
            ...
        }
    }
}

พร็อพเพอร์ตี้นี้มีผลกับโมดูลที่มีโค้ด C/C++ ด้วย

หมายเหตุ: ระบบไม่ได้ใช้พร็อพเพอร์ตี้ jniDebuggable อีกต่อไป

หากแอปของคุณใช้โมดูลไลบรารีที่คุณต้องการแก้ไขข้อบกพร่องด้วย ไลบรารีดังกล่าวต้องรวมอยู่ในแพ็กเกจ debuggable true ด้วยเพื่อเก็บสัญลักษณ์การแก้ไขข้อบกพร่องไว้ โปรดเผยแพร่ไลบรารีเวอร์ชันที่ไม่ใช่ค่าเริ่มต้นเพื่อให้แน่ใจว่าตัวแปรที่แก้ไขข้อบกพร่องได้ของโปรเจ็กต์แอปจะได้รับตัวแปรที่แก้ไขข้อบกพร่องได้ของข้อบังคับของไลบรารี

เริ่มแก้ไขข้อบกพร่อง

คุณเริ่มเซสชันการแก้ไขข้อบกพร่องได้โดยทำดังนี้

1. ตั้งจุดหยุดในโค้ดของแอป
2. ในแถบเครื่องมือ ให้เลือกอุปกรณ์ที่จะแก้ไขข้อบกพร่องของแอปจากเมนูอุปกรณ์เป้าหมาย

   

   หากไม่ได้กำหนดค่าอุปกรณ์ไว้ คุณจะต้องเชื่อมต่ออุปกรณ์ผ่าน USB, เชื่อมต่ออุปกรณ์ผ่าน Wi-Fi หรือสร้าง AVD เพื่อใช้โปรแกรมจำลอง Android

3. คลิกแก้ไขข้อบกพร่อง ในแถบเครื่องมือ

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

   หากคุณเพิ่มโค้ด C และ C++ ลงในโปรเจ็กต์ Android Studio จะเรียกใช้โปรแกรมแก้ไขข้อบกพร่อง LLDB ในหน้าต่างแก้ไขข้อบกพร่องเพื่อแก้ไขข้อบกพร่องของโค้ดเนทีฟด้วย

4. หากหน้าต่างแก้ไขข้อบกพร่องไม่เปิดอยู่ ให้เลือกดู > หน้าต่างเครื่องมือ > แก้ไขข้อบกพร่อง หรือคลิกแก้ไขข้อบกพร่อง ในแถบหน้าต่างเครื่องมือ

แนบโปรแกรมแก้ไขข้อบกพร่องกับแอปที่ทำงานอยู่

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

1. คลิกแนบโปรแกรมแก้ไขข้อบกพร่องกับกระบวนการ Android
2. ในกล่องโต้ตอบเลือกกระบวนการ ให้เลือกกระบวนการที่ต้องการแนบโปรแกรมแก้ไขข้อบกพร่อง
   1. หากใช้โปรแกรมจำลองหรืออุปกรณ์ที่รูท คุณจะดูกระบวนการทั้งหมดได้ที่แสดงกระบวนการทั้งหมด ในอุปกรณ์ที่รูท ระบบจะแสดงกระบวนการทั้งหมดที่ทำงานอยู่ในอุปกรณ์ อย่างไรก็ตาม ในอุปกรณ์ที่ไม่ได้รูท รายการนี้จะแสดงเฉพาะกระบวนการแก้ไขข้อบกพร่องได้เท่านั้น
   2. จากเมนูใช้การตั้งค่าโปรแกรมแก้ไขข้อบกพร่อง Android จาก คุณจะเลือกการกําหนดค่าการเรียกใช้/แก้ไขข้อบกพร่องที่มีอยู่ได้ สำหรับโค้ด C และ C++ ตัวเลือกนี้จะช่วยให้คุณใช้คำสั่งเริ่มต้น LLDB, คำสั่งหลังการแนบ LLDB และไดเรกทอรีสัญลักษณ์ในการกำหนดค่าที่มีอยู่ซ้ำได้
   3. หากไม่มีการกำหนดค่าการเรียกใช้/แก้ไขข้อบกพร่อง ให้เลือกสร้างใหม่ ตัวเลือกนี้เปิดใช้เมนูประเภทการแก้ไขข้อบกพร่อง ซึ่งคุณจะเลือกประเภทการแก้ไขข้อบกพร่องอื่นได้ โดยค่าเริ่มต้น Android Studio จะใช้ประเภทการแก้ไขข้อบกพร่อง "ตรวจหาโดยอัตโนมัติ" เพื่อเลือกตัวเลือกเครื่องมือแก้ไขข้อบกพร่องที่ดีที่สุดให้คุณ โดยขึ้นอยู่กับว่าโปรเจ็กต์มีโค้ด Java หรือ C/C++
3. คลิกตกลง

   หน้าต่างแก้ไขข้อบกพร่องจะปรากฏขึ้น

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

หน้าต่างแก้ไขข้อบกพร่อง

หน้าต่างแก้ไขข้อบกพร่องแบ่งออกเป็น

1. แถบเครื่องมือการเรียกใช้และการนําทาง ดูทํางานกับจุดหยุด
2. ตัวเลือกชุดข้อความ
3. การประเมินและรายการนิพจน์การดู ดูตรวจสอบตัวแปร
4. การแสดงกลุ่ม
5. แผงตัวแปร ดูตรวจสอบตัวแปร

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

เปลี่ยนประเภทโปรแกรมแก้ไขข้อบกพร่อง

เนื่องจากต้องใช้เครื่องมือแก้ไขข้อบกพร่องที่แตกต่างกันในการแก้ไขข้อบกพร่องโค้ด Java/Kotlin และโค้ด C/C++ โปรแกรมแก้ไขข้อบกพร่องของ Android Studio จึงให้คุณเลือกประเภทโปรแกรมแก้ไขข้อบกพร่องที่จะใช้ โดยค่าเริ่มต้น Android Studio จะตัดสินใจว่าจะใช้โปรแกรมแก้ไขข้อบกพร่องใดโดยอิงตามภาษาที่ตรวจพบในโปรเจ็กต์ของคุณโดยใช้ประเภทโปรแกรมแก้ไขข้อบกพร่องตรวจหาโดยอัตโนมัติ

หากต้องการเลือกโปรแกรมแก้ไขข้อบกพร่องด้วยตนเองในการกําหนดค่าการแก้ไขข้อบกพร่อง ให้คลิกเรียกใช้ > แก้ไขการกําหนดค่า คุณยังสามารถเลือกโปรแกรมแก้ไขข้อบกพร่องในกล่องโต้ตอบที่ปรากฏขึ้นเมื่อคลิกเรียกใช้ > แนบโปรแกรมแก้ไขข้อบกพร่องกับกระบวนการ Android

ประเภทการแก้ไขข้อบกพร่องที่ใช้ได้มีดังต่อไปนี้

ตรวจหาโดยอัตโนมัติ

เลือกการแก้ไขข้อบกพร่องประเภทนี้หากต้องการให้ Android Studio เลือกตัวเลือกที่ดีที่สุดโดยอัตโนมัติสำหรับโค้ดที่คุณแก้ไขข้อบกพร่องอยู่ ตัวอย่างเช่น หากคุณมีโค้ด C หรือ C++ ในโปรเจ็กต์ Android Studio จะใช้การแก้ไขข้อบกพร่องแบบคู่โดยอัตโนมัติ มิเช่นนั้น Android Studio จะใช้ประเภทการแก้ไขข้อบกพร่อง Java-Only

Java เท่านั้น

เลือกการแก้ไขข้อบกพร่องประเภทนี้หากต้องการแก้ไขข้อบกพร่องเฉพาะโค้ดที่เขียนด้วย Java หรือ Kotlin โปรแกรมแก้ไขข้อบกพร่องแบบ Java เท่านั้นจะไม่สนใจจุดหยุดพักหรือจุดสังเกตที่คุณตั้งไว้ในโค้ดเนทีฟ

เนทีฟเท่านั้น (ใช้ได้กับโค้ด C/C++ เท่านั้น)

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

การแก้ไขข้อบกพร่องแบบเนทีฟจะใช้งานได้ในอุปกรณ์ที่เป็นไปตามข้อกำหนดต่อไปนี้เท่านั้น

• อุปกรณ์รองรับ run-as

  หากต้องการตรวจสอบว่าอุปกรณ์รองรับ run-as หรือไม่ ให้เรียกใช้คำสั่งต่อไปนี้ในเชลล์ ADB ที่เชื่อมต่อกับอุปกรณ์

  run-as your-package-name pwd
  

  แทนที่ your-package-name ด้วยชื่อแพ็กเกจของแอป หากอุปกรณ์รองรับ run-as คําสั่งควรแสดงผลโดยไม่มีข้อผิดพลาด

• อุปกรณ์เปิดใช้ ptrace ไว้

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

  sysctl kernel.yama.ptrace_scope
  

  หากเปิดใช้ ptrace ไว้ คำสั่งจะพิมพ์ค่า 0 หรือข้อผิดพลาด unknown key หากไม่ได้เปิดใช้ ptrace ระบบจะพิมพ์ค่าอื่นที่ไม่ใช่ 0

แบบคู่ (Java + เนทีฟ) - ใช้ได้กับโค้ด C/C++ เท่านั้น

เลือกการแก้ไขข้อบกพร่องประเภทนี้หากต้องการสลับระหว่างการแก้ไขข้อบกพร่องทั้งโค้ด Java และโค้ดเนทีฟ Android Studio จะแนบทั้งโปรแกรมแก้ไขข้อบกพร่อง Java และ LLDB เข้ากับกระบวนการของแอปเพื่อให้คุณตรวจสอบจุดหยุดพักทั้งโค้ด Java และโค้ดเนทีฟได้โดยไม่ต้องรีสตาร์ทแอปหรือเปลี่ยนการกำหนดค่าการแก้ไขข้อบกพร่อง

ในรูปที่ 2 ให้สังเกตแท็บ 2 แท็บทางด้านขวาของชื่อหน้าต่างแก้ไขข้อบกพร่อง เนื่องจากแอปมีทั้งโค้ด Java และ C++ แท็บหนึ่งจึงใช้แก้ไขข้อบกพร่องโค้ดเนทีฟ และอีกแท็บใช้แก้ไขข้อบกพร่องโค้ด Java ตามที่ระบุโดย -java

หมายเหตุ: ขณะแก้ไขข้อบกพร่องโค้ดเนทีฟที่คอมไพเลอร์เพิ่มประสิทธิภาพ คุณอาจได้รับข้อความเตือนต่อไปนี้
This function was compiled with optimizations enabled. Some debugger features may not be available เมื่อใช้ Flag การเพิ่มประสิทธิภาพ คอมไพเลอร์จะทำการเปลี่ยนแปลงโค้ดที่คอมไพล์แล้วเพื่อให้ทำงานได้อย่างมีประสิทธิภาพมากขึ้น ซึ่งอาจทำให้โปรแกรมแก้ไขข้อบกพร่องรายงานข้อมูลที่ไม่คาดคิดหรือไม่ถูกต้อง เนื่องจากโปรแกรมแก้ไขข้อบกพร่องจะแมปโค้ดที่คอมไพล์ซึ่งเพิ่มประสิทธิภาพแล้วกลับไปยังซอร์สโค้ดเดิมได้ยาก คุณจึงควรปิดใช้การเพิ่มประสิทธิภาพคอมไพเลอร์ขณะแก้ไขข้อบกพร่องโค้ดเนทีฟ

ใช้บันทึกของระบบ

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

เขียนข้อความบันทึกในโค้ด

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

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

Kotlin

import android.util.Log
...
class MyActivity : Activity() {
    ...
    override fun onCreate(savedInstanceState: Bundle?) {
        ...
        if (savedInstanceState != null) {
            Log.d(TAG, "onCreate() Restoring previous state")
            /* restore state */
        } else {
            Log.d(TAG, "onCreate() No saved state available")
            /* initialize app */
        }
        ...
    }
  ...
  companion object {
    private val TAG: String = MyActivity::class.java.simpleName
    ...
  }
}

Java

import android.util.Log;
...
public class MyActivity extends Activity {
    private static final String TAG = MyActivity.class.getSimpleName();
    ...
    @Override
    public void onCreate(Bundle savedInstanceState) {
       ...
       if (savedInstanceState != null) {
            Log.d(TAG, "onCreate() Restoring previous state");
            /* restore state */
        } else {
            Log.d(TAG, "onCreate() No saved state available");
            /* initialize app */
        }
        ...
    }
}

ในระหว่างการพัฒนา โค้ดของคุณยังจับข้อยกเว้นและเขียนสแต็กเทรซลงในบันทึกของระบบได้ด้วย โดยทำดังนี้

Kotlin

fun someOtherMethod() {
    try {
        ...
    } catch (e : SomeException) {
        Log.d(TAG, "someOtherMethod()", e)
    }
}

Java

void someOtherMethod() {
    try {
        ...
    } catch (SomeException e) {
        Log.d(TAG, "someOtherMethod()", e);
    }
}

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

ดูบันทึกของระบบ

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

หากต้องการใช้ Logcat ให้เริ่มแก้ไขข้อบกพร่อง แล้วเลือกแท็บ Logcat

โปรดดูรายละเอียดของ Logcat และตัวเลือกการกรองที่หัวข้อเขียนและดูบันทึกด้วย Logcat

ใช้งานเบรกพอยท์

Android Studio รองรับจุดหยุดพักที่ทริกเกอร์การดำเนินการแก้ไขข้อบกพร่องต่างๆ เบรกพอยต์มีหลายประเภท ดังนี้

เบรกพอยต์บรรทัด

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

เบรกพอยต์เมธอด

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

เบรกพอยต์ของช่อง

จุดหยุดพักของช่องจะหยุดการดําเนินการของแอปชั่วคราวเมื่ออ่านจากหรือเขียนลงในช่องที่เจาะจง

เบรกพอยท์ข้อยกเว้น

จุดหยุดข้อยกเว้นจะหยุดการดําเนินการของแอปชั่วคราวเมื่อมีการส่งข้อยกเว้น

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

หากต้องการเพิ่มจุดหยุดบรรทัด ให้ทําดังนี้

1. ค้นหาบรรทัดโค้ดที่ต้องการหยุดการดําเนินการชั่วคราว
2. คลิกที่ขอบด้านซ้ายของโค้ดบรรทัดนั้นหรือวางเคอร์เซอร์บรรทัดนั้น แล้วกด Control+F8 (ใน macOS ให้กด Command+F8)
3. หากแอปทำงานอยู่แล้ว ให้คลิกแนบโปรแกรมแก้ไขข้อบกพร่องกับกระบวนการ Android หรือหากต้องการเริ่มแก้ไขข้อบกพร่อง ให้คลิกแก้ไขข้อบกพร่อง

จุดสีแดงจะปรากฏข้างบรรทัดเมื่อคุณตั้งจุดหยุดพัก ดังที่แสดงในรูปที่ 5

เมื่อการเรียกใช้โค้ดถึงจุดหยุดพัก Android Studio จะหยุดการเรียกใช้แอปชั่วคราว

หากต้องการระบุสถานะของแอป ให้ใช้เครื่องมือในแท็บโปรแกรมแก้ไขข้อบกพร่อง ดังนี้

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

• หากต้องการไปยังบรรทัดถัดไปในโค้ดโดยไม่ต้องป้อนเมธอด ให้คลิกข้าม

• หากต้องการเลื่อนไปที่บรรทัดแรกภายในการเรียกใช้เมธอด ให้คลิกขั้นตอนใน

• หากต้องการข้ามไปยังบรรทัดถัดไปซึ่งอยู่นอกวิธีการปัจจุบัน ให้คลิก Step Out

• หากต้องการเรียกใช้แอปต่อไปตามปกติ ให้คลิกกลับมาทำงานต่อ

หากโปรเจ็กต์ใช้โค้ดแบบเนทีฟ โดยค่าเริ่มต้นประเภท "ตรวจหาการแก้ไขข้อบกพร่องอัตโนมัติ" จะแนบทั้งโปรแกรมแก้ไขข้อบกพร่อง Java และ LLDB เข้ากับแอปเป็น 2 กระบวนการแยกกัน คุณสลับระหว่างการตรวจสอบเบรกพอยท์ของ Java และ C/C++ ได้โดยไม่ต้องรีสตาร์ทแอปหรือเปลี่ยนการตั้งค่า

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

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

1. Android Studio จะเปลี่ยนไปใช้แท็บ <your-module> เมื่อโปรแกรมแก้ไขข้อบกพร่อง LLDB พบจุดหยุดพักในโค้ด C/C++ นอกจากนี้ บานหน้าต่างเฟรม ตัวแปร และ นาฬิกายังใช้ได้และทำงานในลักษณะเดียวกันหากคุณ แก้ไขข้อบกพร่องของโค้ด Java

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

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

2. Android Studio จะเปลี่ยนไปใช้แท็บ <your-module>-java เมื่อโปรแกรมแก้ไขข้อบกพร่อง Java พบจุดหยุดพักในโค้ด Java หรือ Kotlin
3. ขณะแก้ไขข้อบกพร่องด้วย LLDB คุณสามารถใช้เทอร์มินัล LLDB ในมุมมองเซสชัน LLDB เพื่อส่งตัวเลือกบรรทัดคำสั่งไปยัง LLDB หากมีคำสั่งบางอย่างที่คุณต้องการให้ LLDB ดำเนินการทุกครั้งที่คุณเริ่มแก้ไขข้อบกพร่องแอป ไม่ว่าจะก่อนหรือหลังจากที่โปรแกรมแก้ไขข้อบกพร่องแนบกับกระบวนการของแอป คุณสามารถ เพิ่มคำสั่งเหล่านั้นลงในการกำหนดค่าการแก้ไขข้อบกพร่องได้

ขณะแก้ไขข้อบกพร่องโค้ด C/C++ คุณยังตั้งจุดหยุดพักประเภทพิเศษที่เรียกว่าจุดตรวจสอบได้ ซึ่งจะระงับกระบวนการของแอปเมื่อแอปโต้ตอบกับบล็อกหน่วยความจำที่เฉพาะเจาะจง หากต้องการดูข้อมูลเพิ่มเติม โปรดอ่านส่วนเกี่ยวกับวิธีเพิ่มจุดเฝ้าระวัง

ดูและกำหนดค่าเบรกพอยท์

หากต้องการดูจุดหยุดทั้งหมดและกำหนดการตั้งค่าจุดหยุด ให้คลิกดูจุดหยุด ในหน้าต่างแก้ไขข้อบกพร่อง หน้าต่างจุดหยุดพักจะปรากฏขึ้นดังที่แสดงในรูปที่ 7

หน้าต่างเบรกพอยต์ช่วยให้คุณเปิดหรือปิดใช้เบรกพอยต์แต่ละรายการจากรายการในแผงได้ หากปิดใช้จุดหยุดพักชั่วคราว Android Studio จะไม่หยุดแอปชั่วคราวเมื่อถึงจุดหยุดพักชั่วคราวนั้น

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

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

เฟรมหน้าต่างแก้ไขข้อบกพร่อง

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

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

ตรวจสอบตัวแปร

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

วิธีเพิ่มนิพจน์ลงในต้นไม้ออบเจ็กต์ (ขณะแก้ไขข้อบกพร่องแอปพลิเคชัน)

1. ป้อนนิพจน์เพื่อดูหรือแสดง
2. คลิกเพิ่มลงในรายการติดตามหรือกด Enter เพื่อประเมินนิพจน์ 1 ครั้ง

หรือหากต้นไม้ออบเจ็กต์มีนิพจน์ที่คุณต้องการติดตาม คุณสามารถลากนิพจน์นั้นไปไว้ที่ด้านบนของต้นไม้เพื่อเพิ่มเป็นนิพจน์ที่ติดตาม

นิพจน์ที่ตรวจสอบจะอัปเดตเมื่อถึงจุดหยุดพักหรือคุณเดินหน้าโค้ด

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

หากต้องการนำนิพจน์ที่ตรวจสอบออกจากต้นไม้ออบเจ็กต์ ให้คลิกขวาที่นิพจน์ แล้วคลิกนำการตรวจสอบออก

เพิ่มจุดเฝ้าระวัง

ขณะแก้ไขข้อบกพร่องโค้ด C/C++ คุณสามารถตั้งจุดหยุดพักประเภทพิเศษที่เรียกว่าจุดตรวจสอบ ซึ่งจะระงับกระบวนการของแอปเมื่อแอปโต้ตอบกับบล็อกหน่วยความจำที่เฉพาะเจาะจง ตัวอย่างเช่น หากคุณตั้งค่าพอยน์เตอร์ 2 ตัวไปยังบล็อกหน่วยความจำและกำหนดจุดตรวจสอบให้กับบล็อกนั้น การใช้พอยน์เตอร์ใดพอยน์เตอร์หนึ่งเพื่อเข้าถึงบล็อกหน่วยความจำดังกล่าวจะทริกเกอร์จุดตรวจสอบ

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

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

หากต้องการตั้งจุดตรวจสอบ คุณต้องมีคุณสมบัติตรงตามข้อกำหนดต่อไปนี้

• อุปกรณ์จริงหรือโปรแกรมจำลองเป้าหมายใช้ CPU แบบ x86 หรือ x86_64 หากอุปกรณ์ใช้ CPU ARM คุณต้องจัดแนวขอบเขตของที่อยู่ตัวแปรในหน่วยความจำเป็น 4 ไบต์สําหรับโปรเซสเซอร์ 32 บิต หรือ 8 ไบต์สําหรับโปรเซสเซอร์ 64 บิต หากต้องการจัดแนวตัวแปรในโค้ดเนทีฟ ให้ระบุ __attribute__((aligned(num_bytes))) ในการถดถอยตัวแปร ดังที่แสดงด้านล่าง

  // For a 64-bit ARM processor
  int my_counter __attribute__((aligned(8)));

• คุณกำหนดจุดสังเกตไม่เกิน 3 จุดแล้ว Android Studio รองรับจุดสังเกตได้สูงสุด 4 จุดในอุปกรณ์เป้าหมาย x86 หรือ x86_64 เท่านั้น อุปกรณ์อื่นๆ อาจรองรับจุดสังเกตได้น้อยกว่า

หมายเหตุ: เมื่อแก้ไขข้อบกพร่องของแอปด้วย ARM ABI แบบ 32 บิต การเพิ่มจุดตรวจสอบหรือการวางเมาส์เหนือตัวแปรภายในโค้ดเพื่อตรวจสอบค่าอาจทําให้เกิดความขัดข้อง วิธีแก้ปัญหาชั่วคราวคือการแก้ไขข้อบกพร่องโดยใช้ไบนารี ARM, x86 หรือ x86_64 64 บิต ปัญหานี้จะได้รับการแก้ไขใน Android Studio รุ่นที่กำลังจะเปิดตัว

หากมีคุณสมบัติตรงตามข้อกำหนด คุณจะเพิ่มจุดตรวจสอบได้โดยทำดังนี้

1. ขณะที่แอปหยุดอยู่ที่จุดหยุดพัก ให้ไปที่แผงตัวแปรในมุมมองเซสชัน LLDB

2. คลิกขวาที่ตัวแปรที่ใช้บล็อกหน่วยความจำที่คุณต้องการติดตาม แล้วเลือกเพิ่มจุดเฝ้าระวัง

   

3. กล่องโต้ตอบสำหรับกำหนดค่าจุดตรวจสอบจะปรากฏขึ้นดังที่แสดงในรูปที่ 9

   กำหนดค่าจุดตรวจสอบด้วยตัวเลือกต่อไปนี้

   • เปิดใช้: ยกเลิกการเลือกตัวเลือกนี้หากต้องการบอกให้ Android Studio ละเว้นจุดตรวจสอบจนกว่าคุณจะเปลี่ยนการตั้งค่า Android Studio จะบันทึกจุดเฝ้าระวังของคุณเพื่อให้คุณเข้าถึงในภายหลังได้
   • ระงับ: โดยค่าเริ่มต้น ระบบ Android จะระงับกระบวนการของแอปเมื่อเข้าถึงบล็อกหน่วยความจำที่คุณกำหนดให้กับจุดตรวจสอบ ยกเลิกการเลือกตัวเลือกนี้หากไม่ต้องการลักษณะการทำงานนี้ ซึ่งจะแสดงตัวเลือกเพิ่มเติมที่คุณสามารถใช้เพื่อปรับแต่งลักษณะการทำงานเมื่อระบบโต้ตอบกับจุดสังเกต ซึ่งได้แก่ บันทึกข้อความไปยังคอนโซลและนําออกเมื่อพบ
   • ประเภทการเข้าถึง: เลือกว่าแอปควรทริกเกอร์จุดตรวจสอบเมื่อพยายามอ่านหรือเขียนลงในบล็อกหน่วยความจำที่ระบบจัดสรรให้กับตัวแปรหรือไม่ หากต้องการทริกเกอร์จุดตรวจสอบเมื่อมีการอ่านหรือเขียน ให้เลือกใดก็ได้
4. คลิกเสร็จสิ้น

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

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

ดูและเปลี่ยนรูปแบบการแสดงค่าทรัพยากร

ในโหมดแก้ไขข้อบกพร่อง คุณสามารถดูค่าทรัพยากรและเลือกรูปแบบการแสดงผลอื่นสำหรับตัวแปรในโค้ด Java หรือ Kotlin เมื่อแท็บตัวแปรแสดงอยู่และเลือกเฟรมแล้ว ให้ทําดังนี้

1. ในรายการตัวแปร ให้คลิกขวาที่ใดก็ได้ในบรรทัดทรัพยากรเพื่อแสดงรายการ
2. ในรายการ ให้เลือกดูเป็นและเลือกรูปแบบที่ต้องการใช้

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

   • ชั้นเรียน: แสดงคำจำกัดความของชั้นเรียน
   • toString: แสดงรูปแบบสตริง
   • ออบเจ็กต์: แสดงคำจำกัดความของออบเจ็กต์ (อินสแตนซ์ของคลาส)
   • อาร์เรย์: แสดงในรูปแบบอาร์เรย์
     
   • การประทับเวลา: แสดงวันที่และเวลาดังนี้ yyyy-mm-dd hh:mm:ss
   • อัตโนมัติ: Android Studio จะเลือกรูปแบบที่ดีที่สุดโดยอิงตามประเภทข้อมูล
     
   • ไบนารี: แสดงค่าฐานสองโดยใช้ศูนย์และเลข
   • MeasureSpec: ค่าที่ส่งจากรายการหลักไปยังรายการย่อยที่เลือก โปรดดู MeasureSpec
   • เลขฐานสิบหก: แสดงเป็นค่าฐานสิบหก
   • พื้นฐาน: แสดงเป็นค่าตัวเลขโดยใช้ประเภทข้อมูลพื้นฐาน
   • จำนวนเต็ม: แสดงเป็นค่าตัวเลขประเภท Integer

วิธีสร้างรูปแบบที่กำหนดเอง

1. คลิกขวาที่ค่าทรัพยากร
2. เลือกดูเป็น
3. เลือกสร้าง
4. กล่องโต้ตอบโปรแกรมแสดงผลประเภทข้อมูล Java จะปรากฏขึ้น ทำตามวิธีการที่หัวข้อโปรแกรมแสดงผลประเภทข้อมูล Java