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

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