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

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

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

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

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

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

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

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

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

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

โดยปกติแล้ว คุณสามารถเลือกตัวแปร "debug" เริ่มต้นที่รวมอยู่ในโปรเจ็กต์ 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 ในหน้าต่าง Debug เพื่อแก้ไขข้อบกพร่องของโค้ดแบบเนทีฟด้วย

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

แนบดีบักเกอร์กับแอปที่กำลังทำงาน

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

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

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

แท็บกระบวนการใน Device Explorer (View > Tool Windows > Device Explorer) ยังมีรายการกระบวนการที่แก้ไขข้อบกพร่องได้ด้วย จากนั้นคุณจะเลือกกระบวนการและดำเนินการ kill , force-stop , หรือแนบดีบักเกอร์กับกระบวนการที่กำหนดได้

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

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

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 เท่านั้น

Java เท่านั้น

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

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

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

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

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

หากต้องการเขียนข้อความบันทึกในโค้ด ให้ใช้คลาส 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);
    }
}

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

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

คุณดูและกรองข้อความแก้ไขข้อบกพร่องและข้อความอื่นๆ ของระบบได้ในหน้าต่าง 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 Into

• หากต้องการไปยังบรรทัดถัดไปนอกวิธีการปัจจุบัน ให้คลิก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

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

   หมายเหตุ: ขณะตรวจสอบจุดพักในโค้ดแบบเนทีฟ ระบบ 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++ คุณสามารถตั้งค่าเบรกพอยต์ประเภทพิเศษที่เรียกว่า Watchpoint ซึ่งสามารถระงับกระบวนการของแอปเมื่อแอป โต้ตอบกับบล็อกหน่วยความจำที่เฉพาะเจาะจง ตัวอย่างเช่น หากคุณ ตั้งค่าพอยน์เตอร์ 2 ตัวไปยังบล็อกหน่วยความจำและกำหนด Watchpoint ให้กับบล็อกนั้น การใช้ พอยน์เตอร์ตัวใดตัวหนึ่งเพื่อเข้าถึงบล็อกหน่วยความจำดังกล่าวจะทริกเกอร์ Watchpoint

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

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

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

• อุปกรณ์จริงหรือโปรแกรมจำลองเป้าหมายใช้ 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 รองรับ Watchpoint สูงสุด 4 รายการในอุปกรณ์เป้าหมาย x86 หรือ x86_64 เท่านั้น อุปกรณ์อื่นๆ อาจรองรับจุดตรวจสอบน้อยกว่า

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

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

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

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

   

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

   กำหนดค่า Watchpoint ด้วยตัวเลือกต่อไปนี้

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

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

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

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

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

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

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

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

หากต้องการสร้างรูปแบบที่กำหนดเอง ให้ทำดังนี้

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