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

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. ในแถบเครื่องมือ ให้เลือกอุปกรณ์ที่จะแก้ไขข้อบกพร่องแอปจากเมนูอุปกรณ์เป้าหมาย
    เมนูอุปกรณ์เป้าหมาย
    รูปที่ 1 เมนูอุปกรณ์เป้าหมาย

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

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

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

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

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

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

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

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

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

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

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

รูปที่ 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 เท่านั้น
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

รูปที่ 3 แท็บสำหรับการแก้ไขข้อบกพร่องโค้ดเนทีฟและแท็บสำหรับการแก้ไขข้อบกพร่องโค้ด 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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    รูปที่ 9 เพิ่มจุดตรวจสอบไปยังตัวแปรในหน่วยความจำ

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

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

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

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

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

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

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

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

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

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

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

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

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

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