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

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

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

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

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

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

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

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

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

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

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

ดึงดูด

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

Kotlin

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

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

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

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

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

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

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

   

   รูปที่ 1 เมนูอุปกรณ์เป้าหมาย

   หากไม่ได้กำหนดค่าอุปกรณ์ไว้ คุณจะต้องเชื่อมต่ออุปกรณ์ผ่าน 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. คลิกตกลง

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

แท็บกระบวนการใน Device Explorer (มุมมอง > หน้าต่างเครื่องมือ > Device Explorer) ยังมีรายการกระบวนการที่แก้ไขข้อบกพร่องได้ด้วย จากนั้นคุณสามารถเลือกกระบวนการและทำการหยุด บังคับหยุด หรือแนบโปรแกรมแก้ไขข้อบกพร่องกับกระบวนการที่ระบุ

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

รูปที่ 2 หน้าต่างแก้ไขข้อบกพร่อง

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

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

หมายเหตุ: โปรแกรมแก้ไขข้อบกพร่องและ Garbage Collector ของ 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 Shell ที่เชื่อมต่อกับอุปกรณ์ของคุณ

  run-as your-package-name pwd
  

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

• อุปกรณ์เปิดใช้ ptrace อยู่

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

  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

รูปที่ 3 แท็บสำหรับการแก้ไขข้อบกพร่องของโค้ดแบบเนทีฟและแท็บสำหรับการแก้ไขข้อบกพร่องของโค้ด Java

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

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

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

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

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

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

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

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

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

รูปที่ 4 หน้าต่าง Logcat ที่มีการตั้งค่าตัวกรอง

ดูคำอธิบายของ Logcat และตัวเลือกการกรองได้ที่เขียนและดูบันทึกด้วย Logcat

ทำงานกับเบรกพอยท์

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

เบรกพอยท์ของบรรทัด

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

เบรกพอยท์ของเมธอด

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

เบรกพอยท์ของฟิลด์

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

รูปที่ 6 การแก้ไขข้อบกพร่องของโค้ดแบบเนทีฟโดยใช้ LLDB

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

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

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

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

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

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

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

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

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

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

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

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

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

รูปที่ 8 แผนผังออบเจ็กต์และช่องป้อนนิพจน์ในหน้าต่างแก้ไขข้อบกพร่อง

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

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

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

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

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

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

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

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

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

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

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

   

   รูปที่ 9 เพิ่ม Watchpoint ให้กับตัวแปรในหน่วยความจำ

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

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

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

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

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

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

รูปที่ 11 Android Studio จะระบุบรรทัดโค้ดที่แอปเรียกใช้ก่อนที่จะทริกเกอร์ Watchpoint

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

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

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

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

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

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

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