Time to sync up! Tune in for Google I/O on May 14, 2024. Register now.

หน้านี้ได้รับการแปลโดย Cloud Translation API

Android Kotlin Fundamentals 04.1: วงจรและการบันทึก

Codelab นี้เป็นส่วนหนึ่งของหลักสูตรพื้นฐานเกี่ยวกับ Kotlin ใน Android คุณจะได้รับประโยชน์สูงสุดจากหลักสูตรนี้ หากทํางานผ่าน Codelab ตามลําดับ Codelab ของหลักสูตรทั้งหมดจะแสดงอยู่ในหน้า Landing Page ของ Codelab ของ Android Kotlin Fundamentals

บทนำ

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

วงจร Fragment จะคล้ายกับกิจกรรมเป็นอย่างมาก Codelab นี้มุ่งเน้นที่กิจกรรมเป็นหลัก โดยมีข้อมูลส่วนย่อยที่ถูกต้องที่ตอนท้าย

คุณต้องเข้าใจวงจรกิจกรรมในฐานะนักพัฒนาซอฟต์แวร์ Android หากกิจกรรมตอบสนองการเปลี่ยนแปลงสถานะวงจรได้อย่างถูกต้อง แอปอาจสร้างข้อบกพร่องแปลกๆ พฤติกรรมสับสนสําหรับผู้ใช้ หรือใช้ทรัพยากรระบบ Android มากเกินไป การเข้าใจวงจรการทํางานของ Android และการตอบสนองต่อการเปลี่ยนแปลงสถานะวงจรการใช้งานอย่างถูกต้องเป็นสิ่งสําคัญในการเป็นพลเมืองของ Android ที่ดี

สิ่งที่ควรทราบอยู่แล้ว

กิจกรรมคืออะไร และวิธีสร้างกิจกรรมในแอป
หน้าที่ของเมธอด onCreate() และประเภทการดําเนินการในเมธอดนั้น
วิธีสร้างเลย์เอาต์ XML สําหรับกิจกรรม และวิธีอัปเดตเลย์เอาต์ขณะรันไทม์

สิ่งที่จะได้เรียนรู้

วิธีพิมพ์ข้อมูลการบันทึกไปยัง Logcat (บางครั้งเรียกว่าคอนโซล Android หรือจอภาพ Android)
ข้อมูลพื้นฐานเกี่ยวกับวงจรของ Activity และ Fragment และโค้ดเรียกกลับที่จะเรียกใช้เมื่อกิจกรรมย้ายไปมาระหว่างรัฐ
วิธีลบล้างวิธีเรียกกลับของวงจรชีวิตเพื่อดําเนินการต่างๆ ในช่วงเวลาที่แตกต่างกันในวงจรกิจกรรม
วิธีใช้ไลบรารี Timber สําหรับการบันทึกในแอป

สิ่งที่จะทําได้

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

ใน Codelab นี้ คุณทํางานกับแอปเริ่มต้นที่เรียกว่า DessertClicker ในแอปนี้ ทุกครั้งที่ผู้ใช้แตะของหวานบนหน้าจอ แอป "purchases" ของหวานสําหรับผู้ใช้ แอปจะอัปเดตค่าในเลย์เอาต์สําหรับจํานวนขนมหวานที่ซื้อ และจํานวนเงินรวมที่ผู้ใช้ใช้

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

ทุกกิจกรรมและทุกส่วนย่อยมีสิ่งที่เรียกว่าวงจร อันเป็นการอ้างถึงวงจรชีวิตของสัตว์ อย่างเช่น วงจรชีวิตของผีเสื้อนี้ การพูดลักษณะต่างๆ ของผีเสื้อเติบโตตั้งแต่การเกิดจนถึงวัยเจริญพันธุ์โดยสมบูรณ์

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

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

ส่วนย่อยยังมีวงจรอีกด้วย วงจรของส่วนย่อยจะคล้ายกับวงจรชีวิตของกิจกรรม ดังนั้นสิ่งต่างๆ ที่คุณได้เรียนรู้มากมายจึงมีผลบังคับใช้กับทั้ง 2 อย่างนี้ ใน Codelab นี้ คุณมุ่งเน้นไปที่วงจรกิจกรรมเนื่องจากเป็นส่วนพื้นฐานของ Android และสังเกตได้ง่ายที่สุดในแอปที่เรียบง่าย แผนภาพที่เกี่ยวข้องสําหรับวงจรส่วนย่อย

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

ขั้นตอนที่ 1: ตรวจสอบเมธอด onCreate() และเพิ่มการบันทึก

การดูว่าเกิดอะไรขึ้นกับวงจรการใช้งาน Android การรู้จําวิธีเรียกวงจรต่างๆ ซึ่งจะช่วยค้นหาว่าเกิดข้อผิดพลาดที่ใดบ้างใน DessertClicker

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

ดาวน์โหลดแอป DessertClicker Starter แล้วเปิดใน Android Studio
คอมไพล์และเรียกใช้แอป แล้วแตะหลายครั้งในรูปภาพของหวาน โปรดทราบว่ามูลค่าของ Desserts Sold และจํานวนดอลลาร์รวมเปลี่ยนแปลงไปอย่างไร
เปิด MainActivity.kt และตรวจสอบเมธอด onCreate() สําหรับกิจกรรมนี้

override fun onCreate(savedInstanceState: Bundle?) {
...
}

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

ระบบจะเรียกใช้เมธอดของวงจร onCreate() ครั้งเดียว หลังจากเริ่มต้นกิจกรรมแล้ว (เมื่อสร้างออบเจ็กต์ Activity ใหม่ในหน่วยความจํา) หลังจากที่ดําเนินการ onCreate() แล้ว ระบบจะถือว่ากิจกรรมนั้นสร้างแล้ว

ในเมธอด onCreate() ให้เพิ่มบรรทัดต่อไปนี้หลังการเรียกไปที่ super.onCreate() นําเข้าชั้นเรียน Log หากจําเป็น (กด Alt+Enter หรือ Option+Enter บน Mac แล้วเลือกนําเข้า)

Log.i("MainActivity", "onCreate Called")

ชั้นเรียน Log จะเขียนข้อความไปที่ Logcat คําสั่งนี้มี 3 ส่วน ได้แก่

ความรุนแรงของข้อความในบันทึก ซึ่งก็คือความสําคัญของข้อความ ในกรณีนี้ วิธี Log.i() จะเขียนข้อความให้ข้อมูล วิธีอื่นๆ ในชั้นเรียน Log ได้แก่ Log.e() สําหรับข้อผิดพลาด หรือ Log.w() สําหรับคําเตือน
บันทึกบันทึก ในกรณีนี้คือ "MainActivity" แท็กคือสตริงที่ช่วยให้คุณค้นหาข้อความบันทึกใน Logcat ได้ง่ายขึ้น ซึ่งมักจะเป็นชื่อคลาส
ข้อความบันทึกจริง ซึ่งเป็นสตริงสั้นๆ ซึ่งในกรณีนี้คือ "onCreate called"

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

Logcat เป็นคอนโซลสําหรับบันทึกข้อความ ข้อความจาก Android เกี่ยวกับแอปจะปรากฏขึ้นที่นี่ ซึ่งรวมถึงข้อความที่คุณส่งไปยังบันทึกอย่างชัดแจ้งด้วยเมธอด Log.i() หรือเมธอดคลาส Log อื่นๆ
ในแผง Logcat ให้พิมพ์ I/MainActivity ในช่องค้นหา

Logcat อาจมีหลายข้อความซึ่งโดยส่วนใหญ่ไม่มีประโยชน์สําหรับคุณ คุณสามารถกรองรายการ Logcat ได้หลายวิธี แต่การค้นหาจะง่ายที่สุด เนื่องจากคุณใช้ MainActivity เป็นแท็กบันทึกในโค้ด คุณจึงใช้แท็กดังกล่าวในการกรองบันทึกได้ การเพิ่ม I/ ที่เริ่มต้นหมายความว่านี่คือข้อความให้ข้อมูลที่สร้างโดย Log.i()

ข้อความบันทึกของคุณมีวันที่และเวลา ชื่อแพ็กเกจ (com.example.android.dessertclicker) แท็กบันทึกของคุณ (โดย I/ อยู่ที่ตอนต้น) และข้อความจริง เนื่องจากข้อความนี้ปรากฏในบันทึก คุณจึงทราบว่า onCreate() ดําเนินการแล้ว

ขั้นตอนที่ 2: ใช้เมธอด onStart()

เมธอด onStart() ของเมธอดจะเรียกอยู่หลัง onCreate() หลังจากเรียกใช้ onStart() แล้ว กิจกรรมจะปรากฏบนหน้าจอ ระบบเรียกใช้ onStart() ได้หลายครั้งในวงจรของกิจกรรม ซึ่งต่างจากonCreate()ที่มีการเรียกเพียงครั้งเดียวเพื่อให้เริ่มต้นกิจกรรม

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

ใน Android Studio ที่เปิด MainActivity.kt อยู่ ให้เลือกโค้ด > ลบล้างเมธอด หรือกด Control+o กล่องโต้ตอบจะปรากฏขึ้นพร้อมรายการวิธีการทั้งหมดที่คุณสามารถลบล้างได้ในชั้นเรียนนี้
เริ่มป้อน onStart เพื่อค้นหาวิธีการที่เหมาะสม หากต้องการเลื่อนไปยังรายการที่ตรงกันถัดไป ให้ใช้ลูกศรลง เลือก onStart() จากรายการ และคลิกตกลงเพื่อแทรกรหัสการลบล้าง Boilerplate โค้ดจะมีลักษณะดังนี้

override fun onStart() {
   super.onStart()
}

เพิ่มข้อความบันทึกภายในเมธอด onStart() ดังนี้

override fun onStart() {
   super.onStart()

   Log.i("MainActivity", "onStart Called")
}

คอมไพล์และเรียกใช้แอป DessertClicker จากนั้นเปิดแผง Logcat ป้อน I/MainActivity ในช่องค้นหาเพื่อกรองบันทึก โปรดสังเกตว่าทั้งเมธอด onCreate() และ onStart() จะเรียกใช้กันเอง และกิจกรรมของคุณจะแสดงบนหน้าจอ
กดปุ่ม "หน้าแรก" บนอุปกรณ์แล้วใช้หน้าจอ "ล่าสุด" เพื่อกลับไปที่กิจกรรม โปรดทราบว่ากิจกรรมจะกลับมาทํางานต่อจากที่ค้างไว้ โดยใช้ค่าเดียวกันทั้งหมด และจะมีการบันทึก onStart() เป็นครั้งที่ 2 ของ Logcat โปรดทราบว่าตามปกติแล้วจะไม่มีการเรียกใช้เมธอด onCreate() อีก

ในงานนี้ คุณจะต้องแก้ไขแอปเพื่อใช้ไลบรารีการบันทึกยอดนิยมที่ชื่อว่า Timber Timber มีข้อได้เปรียบมากกว่า Android Log ในตัวหลายประการ โดยเฉพาะอย่างยิ่ง ไลบรารี Timber จะมีลักษณะดังนี้

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

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

ขั้นตอนที่ 1: เพิ่ม Timber ใน Gradle

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

implementation 'com.jakewharton.timber:timber:4.7.1'

ใน Android Studio ในโปรเจ็กต์: มุมมอง Android ให้ขยายสคริปต์ Gradle และเปิดไฟล์ build.gradle (โมดูล: แอป)
วางบรรทัดโค้ดที่คัดลอกไว้ในส่วนการพึ่งพิง

dependencies {
   ...
   implementation 'com.jakewharton.timber:timber:4.7.1'
}

คลิกลิงก์ซิงค์เลยที่ด้านขวาบนของ Android Studio เพื่อสร้าง Gradle อีกครั้ง บิลด์ควรดําเนินการโดยไม่มีข้อผิดพลาด

ขั้นตอนที่ 2: สร้างคลาสแอปพลิเคชันและเริ่มต้น Timber

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

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

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

หลังจากสร้างชั้นเรียนใน Application แล้ว คุณต้องระบุชั้นเรียนในไฟล์ Manifest ของ Android

ในแพ็กเกจ dessertclicker ให้สร้างคลาส Kotlin ใหม่ที่ชื่อว่า ClickerApplication วิธีการคือขยาย app > java แล้วคลิกขวาที่ com.example.android.dessertclicker เลือก New > Kotlin File/Class
ตั้งชื่อคลาสเป็น ClickerApplication และตั้งค่าประเภทเป็นคลาส คลิก OK

Android Studio สร้างชั้นเรียน ClickerApplication ใหม่ และเปิดในตัวแก้ไขโค้ด โค้ดจะมีลักษณะดังนี้

package com.example.android.dessertclicker

class ClickerApplication {
}

เปลี่ยนคําจํากัดความของชั้นเรียนเป็นคลาสย่อยของ Application และนําเข้าคลาส Application หากจําเป็น

class ClickerApplication : Application() {

หากต้องการลบล้างเมธอด onCreate() ให้เลือก Code > Override Methods หรือกด Control+o

class ClickerApplication : Application() {
   override fun onCreate() {
       super.onCreate()
   }
}

ภายในเมธอด onCreate() นั้น ให้เริ่มต้นไลบรารี Timber ดังนี้

override fun onCreate() {
    super.onCreate()

    Timber.plant(Timber.DebugTree())
}

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

เปิด AndroidManifest.xml
ที่ด้านบนขององค์ประกอบ <application> ให้เพิ่มแอตทริบิวต์ใหม่สําหรับคลาส ClickerApplication เพื่อให้ Android ทราบว่าจะใช้คลาส Application แทนคลาสเริ่มต้น

<application
   android:name=".ClickerApplication"
...

ขั้นตอนที่ 3: เพิ่มคําสั่งบันทึกของ Timber

ในขั้นตอนนี้ คุณจะเปลี่ยนการโทรของ Log.i() ไปใช้ Timber จากนั้นจึงใช้การบันทึกสําหรับวิธีการอื่นๆ ในวงจรทั้งหมด

เปิด MainActivity แล้วเลื่อนไปที่ onCreate() แทนที่ Log.i() ด้วย Timber.i() และนําแท็กบันทึกออก

Timber.i("onCreate called")

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

ในทํานองเดียวกัน ให้เปลี่ยนการโทร Log ใน onStart() ดังนี้

override fun onStart() {
   super.onStart()

   Timber.i("onStart Called")
}

คอมไพล์และเรียกใช้ DessertClicker และเปิดแอป Logcat โปรดสังเกตว่าคุณยังคงเห็นข้อความในบันทึกเดียวกันสําหรับ onCreate() และ onStart() เพียงแต่ตอนนี้ Timber จะสร้างข้อความเหล่านั้น ไม่ใช่ชั้นเรียน Log
ลบล้างส่วนที่เหลือของเมธอดในวงจรใน MainActivity และเพิ่มคําสั่งบันทึกของ Timber สําหรับแต่ละเมธอด โค้ดมีดังนี้

override fun onResume() {
   super.onResume()
   Timber.i("onResume Called")
}

override fun onPause() {
   super.onPause()
   Timber.i("onPause Called")
}

override fun onStop() {
   super.onStop()
   Timber.i("onStop Called")
}

override fun onDestroy() {
   super.onDestroy()
   Timber.i("onDestroy Called")
}

override fun onRestart() {
   super.onRestart()
   Timber.i("onRestart Called")
}

คอมไพล์และเรียกใช้ DessertClicker อีกครั้งและตรวจสอบ Logcat ครั้งนี้สังเกตเห็นว่า นอกจาก onCreate() และ onStart() แล้ว จะมีข้อความบันทึกสําหรับโค้ดเรียกกลับของ onResume() ด้วย

เมื่อกิจกรรมเริ่มตั้งแต่ต้น คุณจะเห็นการเรียกกลับตลอดอายุการใช้งานทั้ง 3 รายการที่เรียกใช้ตามลําดับ

onCreate()เพื่อสร้างแอป
onStart() เพื่อเริ่มต้นและแสดงบนหน้าจอ
onResume() เพื่อมุ่งเน้นกิจกรรมและช่วยให้ผู้ใช้โต้ตอบกับกิจกรรมได้

แม้จะมีชื่อเดิม แต่เมธอด onResume() จะถูกเรียกเมื่อเริ่มต้น แม้ว่าจะไม่มีการดําเนินการใดๆ ให้กลับมาทํางานอีกครั้งก็ตาม

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

กรณีการใช้งาน 1: การเปิดและปิดกิจกรรม

คุณเริ่มต้นด้วยกรณีการใช้งานพื้นฐานที่สุด นั่นคือการเริ่มต้นแอปเป็นครั้งแรก จากนั้นปิดแอปโดยสิ้นเชิง

คอมไพล์และเรียกใช้แอป DessertClicker หากยังไม่ได้เรียกใช้ ตามที่เห็น &onCreate(), onStart() และ onResume() ระบบจะเรียกโค้ดเรียกกลับเมื่อกิจกรรมเริ่มต้นขึ้นเป็นครั้งแรก
แตะคัพเค้ก 2-3 ครั้ง
แตะปุ่ม "กลับ" ในอุปกรณ์ โปรดทราบใน Logcat ว่า onPause(), onStop() และ onDestroy() ถูกเรียกใช้ตามลําดับ

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

นอกจากนี้ระบบอาจปิดการทํางานทั้งหมดหากโค้ดเรียกใช้เมธอด finish() ของกิจกรรมด้วยตนเอง หรือหากผู้ใช้บังคับให้แอปปิด (เช่น ผู้ใช้สามารถบังคับให้แอปอยู่ในหน้าจอล่าสุดด้วยการคลิก X ที่มุมของหน้าต่าง) ระบบ Android อาจปิดกิจกรรมของคุณด้วยตัวเองหากแอปของคุณไม่ปรากฏขึ้นบนหน้าจอเป็นเวลานาน Android ทําเช่นนี้เพื่อประหยัดแบตเตอรี่และเพื่อให้แอปอื่นๆ ใช้ทรัพยากรของแอปได้
ใช้หน้าจอล่าสุดเพื่อกลับไปที่แอป นี่คือ Logcat:

กิจกรรมถูกทําลายในขั้นตอนก่อนหน้า ดังนั้นเมื่อคุณกลับไปยังแอป Android จะเริ่มกิจกรรมใหม่ และเรียกเมธอด onCreate(), onStart() และ onResume() โปรดสังเกตว่าไม่มีการเก็บสถิติ DessertClicker จากกิจกรรมก่อนหน้าไว้

ประเด็นสําคัญคือ onCreate() จะเรียกใช้ onDestroy() เพียงครั้งเดียวตลอดอายุการใช้งานอินสแตนซ์เดียว: onCreate() เพื่อเริ่มต้นใช้งานแอปเป็นครั้งแรก และ onDestroy() เพื่อล้างทรัพยากรที่แอปใช้

เมธอด onCreate() เป็นขั้นตอนสําคัญ ซึ่งเป็นจุดที่การเริ่มต้นครั้งแรกทั้งหมด ซึ่งคุณจะตั้งค่าเลย์เอาต์เป็นครั้งแรกโดยตั้งตัวแปรและเริ่มต้นตัวแปร

กรณีการใช้งาน 2: การออกจากและกลับไปยังกิจกรรม

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

กิจกรรมของคุณจะไม่ปิดทั้งหมดทุกครั้งที่ผู้ใช้ออกจากกิจกรรมนั้น:

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

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

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

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

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

ขณะที่แอป DessertClicker เปิดอยู่ ให้คลิกคัพเค้ก 2-3 ครั้ง
กดปุ่ม "หน้าแรก" ในอุปกรณ์และสังเกต Logcat ใน Android Studio การกลับไปยังหน้าจอหลักจะทําให้แอปทํางานอยู่เบื้องหลัง ไม่ใช่ปิดแอปไปเลย โปรดสังเกตว่ามีการเรียกเมธอด onPause() และเมธอด onStop() แต่ไม่มีการเรียก onDestroy()

เมื่อมีการเรียกใช้ onPause() แอปจะไม่มีโฟกัสอีกต่อไป หลังจากวันที่ onStop() แอปจะไม่ปรากฏบนหน้าจออีกต่อไป แม้ว่ากิจกรรมจะหยุดลง แต่ออบเจ็กต์ Activity ยังคงอยู่ในหน่วยความจําในเบื้องหลัง ไม่มีการทําลายกิจกรรม ผู้ใช้อาจกลับมาที่แอป Android จะเก็บทรัพยากรกิจกรรมเอาไว้
ใช้หน้าจอล่าสุดเพื่อกลับสู่แอป สังเกตใน Logcat ว่าได้รีสตาร์ทกิจกรรมด้วย onRestart() และ onStart() แล้วดําเนินการต่อด้วย onResume()

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

สังเกตเห็นว่าคุณเห็นโค้ดเรียกกลับใน Logcat ที่นี่เหมือนกับตอนกดปุ่มหน้าแรก ระบบจะเรียกใช้ onPause() และ onStop() เมื่อแอปเข้าสู่พื้นหลัง ตามด้วย onRestart(), onStart() และ onResume() เมื่อแอปกลับมา

ประเด็นสําคัญคือ onStart() และ onStop() จะเรียกใช้หลายครั้งเมื่อผู้ใช้ไปยังและออกจากกิจกรรม คุณควรลบล้างเมธอดเหล่านี้เพื่อหยุดแอปเมื่อแอปย้ายไปอยู่ในพื้นหลัง หรือเริ่มต้นอีกครั้งเมื่อกลับสู่เบื้องหน้า

แล้ว onRestart() ล่ะ เมธอด onRestart() จะคล้ายกับ onCreate() ระบบจะเรียกใช้ onCreate() หรือ onRestart() ก่อนที่จะแสดงกิจกรรม ระบบจะเรียกเมธอด onCreate() เฉพาะครั้งแรก และจะเรียก onRestart() ในหลังจากนั้น เมธอด onRestart() คือตําแหน่งที่จะใส่โค้ดที่ต้องการเรียกใช้เมื่อกิจกรรมไม่ได้เริ่มต้นเป็นครั้งแรกเท่านั้น

กรณีการใช้งาน 3: ซ่อนกิจกรรมบางส่วน

คุณได้ทราบว่าเมื่อแอปเริ่มทํางานและมีการเรียก onStart() แล้ว แอปจะปรากฏบนหน้าจอ เมื่อมีการกลับมาใช้งานแอปอีกครั้ง และระบบจะเรียกใช้ onResume() แอปจะมุ่งเน้นไปที่ผู้ใช้ ส่วนหนึ่งของวงจรที่แอปแสดงบนหน้าจออย่างเต็มรูปแบบและมีมุ่งเน้นผู้ใช้เรียกว่าวงจรการโต้ตอบ

เมื่อแอปเข้าสู่พื้นหลัง โฟกัสจะหายไปหลังจากวันที่ onPause() และแอปจะไม่ปรากฏหลังจาก onStop() อีกต่อไป

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

ขณะที่แอป DessertClicker ทํางานอยู่ ให้คลิกปุ่มแชร์ที่ด้านขวาบนของหน้าจอ

กิจกรรมการแชร์จะปรากฏขึ้นในครึ่งล่างของหน้าจอ แต่กิจกรรมจะยังคงปรากฏอยู่ที่ครึ่งบน
ตรวจสอบ Logcat และโปรดทราบว่ามีการเรียกเฉพาะ onPause() เท่านั้น

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

ความแตกต่างนี้สําคัญอย่างไร ลองพิจารณาแอปฟิสิกส์ คุณอาจต้องการให้การจําลองหยุดเมื่อแอปอยู่เบื้องหลังและทํางานต่อไปเมื่อแอปถูกบดบังบางส่วน ในกรณีนี้ คุณจะหยุดการจําลองใน onStop() หากคุณต้องการให้การจําลองหยุดลงเมื่อกิจกรรมถูกบดบังบางส่วน ให้วางโค้ดเพื่อหยุดการจําลองใน onPause()

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

ทั้ง onResume() และ onPause() ต่างต้องโฟกัส ระบบจะเรียกใช้เมธอด onResume() เมื่อกิจกรรมมีการโฟกัสไว้ และจะมีการเรียก onPause() เมื่อมีการสูญเสียกิจกรรม

อายุการใช้งานของ Android Fragment นั้นคล้ายกับวงจรการใช้งานกิจกรรม รวมถึงวิธีการที่เจาะจงส่วนย่อยหลายข้อ

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

หน้าจอแต่ละหน้าจอในแอป AndroidTrivia ก็คือ Fragment

เพื่อความเรียบง่าย คุณสามารถใช้ API การบันทึกของ Android ในงานนี้แทนที่จะใช้ไลบรารี Timber

เปิดแอป AndroidTrivia จาก Codelab ล่าสุด หรือดาวน์โหลดโค้ดโซลูชัน AndroidTrivia จาก GitHub
เปิดไฟล์ TitleFragment.kt โปรดทราบว่า Android Studio อาจแสดงข้อผิดพลาดในการเชื่อมโยงและข้อผิดพลาดข้อมูลอ้างอิงที่ยังไม่ได้แก้ไขจนกว่าคุณจะสร้างแอปอีกครั้ง
เลื่อนลงไปที่เมธอด onCreateView() โปรดสังเกตว่าเลย์เอาต์ของ Fragment พองขึ้นและสร้างการเชื่อมโยงข้อมูลไว้ที่นี่
เพิ่มคําสั่งการบันทึกไปยังเมธอด onCreateView() ระหว่างบรรทัดไปยัง setHasOptionsMenu() และการเรียกขั้นสุดท้ายเพื่อแสดงผล ดังนี้

setHasOptionsMenu(true)

Log.i("TitleFragment", "onCreateView called")

return binding.root

ใต้เมธอด onCreateView() ให้เพิ่มคําสั่งการบันทึกสําหรับเมธอดวงจรส่วนย่อยแต่ละเมธอดที่เหลือ รหัสคือ

override fun onAttach(context: Context?) {
   super.onAttach(context)
   Log.i("TitleFragment", "onAttach called")
}
override fun onCreate(savedInstanceState: Bundle?) {
   super.onCreate(savedInstanceState)
   Log.i("TitleFragment", "onCreate called")
}
override fun onActivityCreated(savedInstanceState: Bundle?) {
   super.onActivityCreated(savedInstanceState)
   Log.i("TitleFragment", "onActivityCreated called")
}
override fun onStart() {
   super.onStart()
   Log.i("TitleFragment", "onStart called")
}
override fun onResume() {
   super.onResume()
   Log.i("TitleFragment", "onResume called")
}
override fun onPause() {
   super.onPause()
   Log.i("TitleFragment", "onPause called")
}
override fun onStop() {
   super.onStop()
   Log.i("TitleFragment", "onStop called")
}
override fun onDestroyView() {
   super.onDestroyView()
   Log.i("TitleFragment", "onDestroyView called")
}
override fun onDetach() {
   super.onDetach()
   Log.i("TitleFragment", "onDetach called")
}

คอมไพล์และเรียกใช้แอป แล้วเปิด Logcat
พิมพ์ I/TitleFragment ในช่องค้นหาเพื่อกรองบันทึก เมื่อเริ่มแอป Logcat อาจมีลักษณะคล้ายกับภาพหน้าจอต่อไปนี้

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

onAttach(): เรียกใช้เมื่อส่วนย่อยเชื่อมโยงกับกิจกรรมของเจ้าของ
onCreate(): ในทํานองเดียวกันกับ onCreate() สําหรับกิจกรรม ระบบจะเรียก onCreate() สําหรับส่วนย่อยเพื่อสร้างส่วนย่อยเริ่มต้น (นอกเหนือจากเลย์เอาต์)
onCreateView(): เรียกใช้เลย์เอาต์เลย์เอาต์ส่วนย่อยให้สูงเกินความเป็นจริง
onActivityCreated(): โทรหาคุณเมื่อกิจกรรมของเจ้าของเสร็จสมบูรณ์ onCreate() Fragment ของคุณจะเข้าถึงกิจกรรมไม่ได้จนกว่าจะเรียกใช้เมธอดนี้
onStart(): เรียกใช้เมื่อส่วนย่อยมองเห็นได้ ขนานกับกิจกรรม onStart()
onResume(): เรียกใช้เมื่อส่วนย่อยได้รับโฟกัสของผู้ใช้ ขนานกับกิจกรรม onResume()

แตะปุ่มเล่นเพื่อเล่นเกมทายปัญหา และสังเกต Logcat เลย

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

onPause(): เรียกใช้เมื่อส่วนย่อยสูญเสียโฟกัสของผู้ใช้ ขนานกับกิจกรรม onPause()
onStop(): เรียกใช้เมื่อส่วน Fragment ไม่ปรากฏบนหน้าจออีกต่อไป โดยให้ขนานกับกิจกรรม onStop()
onDestroyView(): เรียกใช้เมื่อไม่จําเป็นต้องใช้มุมมองส่วนย่อยอีกต่อไป เพื่อล้างทรัพยากรที่เชื่อมโยงกับข้อมูลพร็อพเพอร์ตี้นั้น

ในแอป ให้แตะปุ่มลูกศรขึ้น (ลูกศรที่มุมซ้ายบนของหน้าจอ) เพื่อกลับไปที่ส่วนย่อยของชื่อ

ครั้งนี้อาจไม่มีการเรียก onAttach() และ onCreate() เพื่อเริ่มส่วนย่อย ออบเจ็กต์ส่วนย่อยยังคงอยู่และยังคงแนบไปยังกิจกรรมของเจ้าของ ดังนั้นอายุการใช้งานจึงขึ้นต้นด้วย onCreateView() อีกครั้ง
กดปุ่มหน้าแรกของอุปกรณ์ สังเกตใน Logcat ที่มีการเรียก onPause() และ onStop() เท่านั้น ลักษณะการทํางานเช่นนี้จะเหมือนกับการที่กิจกรรมกลับมา และระบบจะวางกิจกรรมและส่วนย่อยลงในพื้นหลัง
ใช้หน้าจอล่าสุดเพื่อกลับไปที่แอป เช่นเดียวกับที่เคยเกิดขึ้นสําหรับกิจกรรม ระบบจะเรียกใช้เมธอด onStart() และ onResume() เพื่อเรียกส่วนย่อยกลับมาเบื้องหน้า

โปรเจ็กต์ Android Studio: DessertClickerLogs

วงจรกิจกรรม

วงจรกิจกรรมคือชุดของสถานะที่ย้ายข้อมูลกิจกรรมไป วงจรกิจกรรมจะเริ่มต้นเมื่อมีการสร้างกิจกรรมครั้งแรกและสิ้นสุดเมื่อกิจกรรมถูกทําลาย
เมื่อผู้ใช้เลื่อนดูระหว่างกิจกรรมภายในและภายนอกแอป แต่ละกิจกรรมจะย้ายไประหว่างสถานะต่างๆ ในวงจรกิจกรรม
แต่ละรัฐในวงจรกิจกรรมจะมีวิธีเรียกกลับที่เกี่ยวข้องซึ่งคุณลบล้างได้ในชั้นเรียน Activity อายุการใช้งานมี 7 วิธี ได้แก่
onCreate()
onStart()
onPause()
onRestart()
onResume()
onStop()
onDestroy()
หากต้องการเพิ่มลักษณะการทํางานที่เกิดขึ้นเมื่อกิจกรรมเปลี่ยนเป็นสถานะอายุการใช้งาน ให้ลบล้างวิธีเรียกกลับของรัฐ
หากต้องการเพิ่มวิธีการลบล้างโครงกระดูกในชั้นเรียนใน Android Studio ให้เลือกCode > Override Methods หรือกด Control+o

การบันทึกด้วย Log

Android Logging API โดยเฉพาะคลาส Log จะช่วยให้คุณเขียนข้อความสั้นๆ ที่แสดงใน Logcat ภายใน Android Studio ได้
ใช้ Log.i() เพื่อเขียนข้อความให้ข้อมูล วิธีนี้ใช้อาร์กิวเมนต์ 2 รายการ ได้แก่ บันทึก tag ซึ่งโดยปกติจะเป็นชื่อคลาส และบันทึก message เป็นสตริงสั้นๆ
ใช้แผง Logcat ใน Android Studio เพื่อดูบันทึกของระบบ ซึ่งรวมถึงข้อความที่คุณเขียน

การบันทึกด้วย Timber

Timber เป็นไลบรารีการบันทึกที่มีข้อดีมากกว่า Android Logging API โดยเฉพาะอย่างยิ่ง ไลบรารี Timber จะมีลักษณะดังนี้

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

หากต้องการใช้ Timber ให้เพิ่มทรัพยากรดังกล่าวลงในไฟล์ Gradle และขยายคลาส Application เพื่อเริ่มต้น

Application เป็นคลาสพื้นฐานที่มีสถานะแอปพลิเคชันส่วนกลางสําหรับทั้งแอปของคุณ มีคลาส Application ที่ Android ใช้เป็นค่าเริ่มต้นหากคุณไม่ได้ระบุ คุณจะสร้างคลาส Application ของตัวเองเพื่อเริ่มไลบรารีสําหรับทั้งแอป เช่น Timber ได้
เพิ่มคลาส Application ที่กําหนดเองลงในแอปโดยเพิ่มแอตทริบิวต์ android:name ในองค์ประกอบ <application> ในไฟล์ Manifest ของ Android อย่าลืมทําสิ่งนี้นะ
ใช้ Timber.i() เพื่อเขียนข้อความบันทึกด้วย Timber วิธีการนี้ใช้อาร์กิวเมนต์เพียงรายการเดียว ซึ่งได้แก่ ข้อความที่จะเขียน ระบบจะเพิ่มแท็กบันทึก (ชื่อคลาส) ให้คุณโดยอัตโนมัติ

หลักสูตร Udacity:

การพัฒนาแอป Android ด้วย Kotlin

เอกสารประกอบสําหรับนักพัฒนาซอฟต์แวร์ Android

กิจกรรม (คําแนะนําเกี่ยวกับ API)
ส่วนย่อย (คําแนะนํา API)
Activity (เอกสารอ้างอิง API)
Fragment (เอกสารอ้างอิง API)
ทําความเข้าใจวงจรการใช้งานกิจกรรม
เขียนและดูบันทึกด้วย Logcat
Log (เอกสารอ้างอิง API)

อื่นๆ:

Timber (GitHub)
ข้อมูลสรุปของ Android Lifecycle - ตอนที่ 1: กิจกรรมเดียวคือสรุปเนื้อหาส่วนใหญ่เป็นภาพที่นี่
ข้อมูลสรุปเกี่ยวกับวงจรการใช้งาน Android - ตอนที่ 2: กิจกรรมหลายรายการแสดงลําดับของการเรียกอายุการใช้งานเมื่อมีกิจกรรม 2 อย่างโต้ตอบ
ข้อมูลสรุปเกี่ยวกับวงจรการใช้งาน Android - ตอนที่ 3: ส่วนย่อยแสดงลําดับของการเรียกอายุการใช้งานเมื่อกิจกรรมและส่วนย่อยมีการโต้ตอบ

ส่วนนี้จะอธิบายการบ้านและรายงานสําหรับนักเรียนที่ทํางานผ่าน Codelab นี้ซึ่งเป็นส่วนหนึ่งของหลักสูตรที่นําโดยผู้สอน สิ่งที่ผู้สอนต้องทํามีดังนี้

มอบหมายการบ้านหากจําเป็น
สื่อสารกับนักเรียนเกี่ยวกับวิธีส่งงานทําการบ้าน
ตัดเกรดการบ้าน

ผู้สอนจะใช้คําแนะนําเหล่านี้เท่าใดก็ได้หรือตามที่ต้องการก็ได้ และสามารถกําหนดให้การบ้านอื่นๆ ที่ตนคิดว่าเหมาะสมได้

หากคุณใช้ Codelab ด้วยตัวเอง ก็ให้ใช้การบ้านเพื่อทดสอบความรู้ของคุณได้

เปลี่ยนแอป

เปิดแอป DiceRoller จากบทเรียนที่ 1 (คุณดาวน์โหลดแอป DiceRoller ได้ที่นี่หากไม่มีแอป) เพิ่มการรองรับ Timber ในแอปดังกล่าว โดยใช้ขั้นตอนเดียวกันกับที่คุณใช้สําหรับแอป DessertClicker ลบล้างโค้ดเรียกกลับตลอดอายุการใช้งานทั้งหมด และเพิ่มข้อความบันทึกสําหรับโค้ดเรียกกลับแต่ละรายการ

ตอบคําถามเหล่านี้

คำถามที่ 1

ข้อใดต่อไปนี้ไม่ใช่สถานะในวงจรกิจกรรม

เริ่มต้นแล้ว
กำลังรอ
สร้างเมื่อ
ทำลายแล้ว

คำถามที่ 2

วิธีใดเรียกใช้วงจรเพื่อทําให้กิจกรรมปรากฏ

onPause()
onVisible()
onStart()
onDestroy()

คำถามที่ 3

วิธีใดในวงจรชีวิตที่มุ่งเน้นที่กิจกรรม

onResume()
onVisible()
onStart()
onFocus()

คำถามที่ 4

onCreate() จะเข้าร่วมกิจกรรมเมื่อใด

ทุกครั้งที่ผู้ใช้เห็นกิจกรรม
ทุกครั้งที่กิจกรรมส่งกลับจากพื้นหลัง
เมื่อสร้างกิจกรรมเท่านั้นเพียงครั้งเดียว
เฉพาะเวลาที่กิจกรรมกลับมาทํางานอีกครั้ง

ส่งแอปเพื่อตัดเกรด

ตรวจสอบว่าแอปมีคุณสมบัติต่อไปนี้

การขึ้นต่อ Timber ในไฟล์ build.gradle ของแอป
คลาสย่อยของ Application ที่กําหนดเองซึ่งขึ้นต้นด้วย Timber ใน onCreate()
แอตทริบิวต์สําหรับคลาสย่อยที่กําหนดเองในไฟล์ Manifest ของ Android
เมธอดจะลบล้างใน MainActivity สําหรับเมธอดเรียกกลับตลอดอายุการใช้งาน โดยเรียกไปยัง Timber.i() สําหรับการบันทึก

เริ่มบทเรียนถัดไป: 4.2: สถานการณ์ในวงจรที่ซับซ้อน

สําหรับลิงก์ไปยัง Codelab อื่นๆ ในหลักสูตรนี้ โปรดดูหน้า Landing Page ของ Codelab ของ Android Kotlin Fundamentals