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

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

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

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

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

โปรดทําตามขั้นตอนต่อไปนี้ก่อนเริ่มแก้ไขข้อบกพร่อง

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

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

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

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

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

ดึงดูดKotlin

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

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, ลงชื่อ 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. คลิกตกลง

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

แท็บกระบวนการในโปรแกรมสำรวจอุปกรณ์ (มุมมอง > 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 ที่เชื่อมต่อกับอุปกรณ์

  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

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

KotlinJava

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
    ...
  }
}

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 */
        }
        ...
    }
}

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

KotlinJava

fun someOtherMethod() {
    try {
        ...
    } catch (e : SomeException) {
        Log.d(TAG, "someOtherMethod()", e)
    }
}

void someOtherMethod() {
    try {
        ...
    } catch (SomeException e) {
        Log.d(TAG, "someOtherMethod()", e);
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

นิพจน์ที่ตรวจสอบจะอัปเดตเมื่อถึงจุดหยุดพักหรือคุณเดินหน้าโค้ด

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

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

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

ขณะแก้ไขข้อบกพร่องของโค้ด 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 ARM 32 บิต การเพิ่มจุดเฝ้าระวังหรือการวางเมาส์เหนือ ทับตัวแปรภายในโค้ดเพื่อตรวจสอบ ค่านั้นอาจทำให้เกิดข้อขัดข้อง วิธีแก้ปัญหาชั่วคราวคือการแก้ไขข้อบกพร่องโดยใช้ไบนารี ARM, x86 หรือ x86_64 64 บิต ปัญหานี้จะได้รับการแก้ไขในรุ่น Android Studio ที่กำลังจะเปิดตัว

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

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

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

   

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

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

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

   • เปิดใช้: ยกเลิกการเลือกตัวเลือกนี้หากต้องการบอกให้ Android Studio ละเว้นจุดตรวจสอบจนกว่าคุณจะเปลี่ยนการตั้งค่า Android 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 จะเลือกรูปแบบที่ดีที่สุดโดยอิงตามประเภทข้อมูล
     
   • ฐานสอง: แสดงค่าฐานสองโดยใช้เลข 0 และ 1
   • MeasureSpec: ค่าที่ส่งจากระดับบนสุดไปยังหน่วยย่อยที่เลือก โปรดดู MeasureSpec
   • Hex: แสดงเป็นค่าฐานสิบหก
   • พื้นฐาน: แสดงเป็นค่าตัวเลขโดยใช้ประเภทข้อมูลพื้นฐาน
   • จำนวนเต็ม: แสดงเป็นค่าตัวเลขประเภท Integer

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

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