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

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

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

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

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

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

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

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

ตามปกติแล้ว คุณสามารถเลือก "การแก้ไขข้อบกพร่อง" ซึ่งเป็นค่าเริ่มต้น ตัวแปรที่รวมอยู่ใน 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. คลิกแก้ไขข้อบกพร่อง ในแถบเครื่องมือ

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

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

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

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

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

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

  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-Only โปรแกรมแก้ไขข้อบกพร่องจะไม่สนใจเบรกพอยท์หรือนาฬิกาที่คุณตั้งค่าไว้ในโค้ดเนทีฟ
เนทีฟเท่านั้น (ใช้ได้เฉพาะกับโค้ด 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

Dual (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 รองรับเบรกพอยท์ที่ ทริกเกอร์การดำเนินการแก้ไขข้อบกพร่องต่างๆ เบรกพอยท์มีหลายประเภท ได้แก่

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

รูปที่ 7 หน้าต่างจุดหยุดแสดงรายการจุดหยุดปัจจุบันทั้งหมด รวมถึงการตั้งค่าลักษณะการทํางานของแต่ละรายการ

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

ขณะแก้ไขข้อบกพร่องของโค้ด 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 เท่านั้น สนับสนุนจุดเฝ้าระวังได้สูงสุดสี่จุดบนอุปกรณ์เป้าหมาย x86 หรือ x86_64 อื่นๆ อุปกรณ์อาจรองรับจุดเฝ้าระวังน้อยลง

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

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

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

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

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

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

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

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

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

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

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

รูปที่ 11 Android Studio ระบุบรรทัดโค้ดที่ แอปของคุณทำงานก่อนที่จะทริกเกอร์จุดเฝ้าระวัง

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

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

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

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

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

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

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