Android Kotlin Fundamentals 04.2: สถานการณ์ในวงจรที่ซับซ้อน

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

บทนำ

ใน Codelab ที่ผ่านมา คุณได้เรียนรู้เกี่ยวกับวงจรของ Activity และ Fragment และได้สํารวจวิธีการที่เรียกเมื่อสถานะอายุการใช้งานมีการเปลี่ยนแปลงเกี่ยวกับกิจกรรมและส่วนย่อย ใน Codelab นี้ คุณจะได้สํารวจวงจรกิจกรรมโดยละเอียด นอกจากนี้คุณยังได้เรียนรู้เกี่ยวกับไลบรารีวงจรการใช้งาน Android Jetpack&#39 ซึ่งจะช่วยคุณจัดการเหตุการณ์ในวงจรของโค้ดด้วยการจัดระเบียบที่ดียิ่งขึ้นและดูแลรักษาได้ง่ายขึ้น

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

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

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

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

สิ่งที่คุณจะทํา

• แก้ไขแอป DessertClicker ให้มีฟังก์ชันตัวจับเวลา แล้วเริ่มและหยุดตัวจับเวลานั้นในช่วงเวลาต่างๆ ในวงจรกิจกรรม
• แก้ไขแอปเพื่อใช้ไลบรารีวงจรการใช้งาน Android และแปลงคลาส DessertTimer เป็นการสังเกตการณ์วงจรการใช้งาน
• ตั้งค่าและใช้ Android Debug Bridge (adb) เพื่อจําลองการปิดกระบวนการของแอปและการเรียกกลับตลอดอายุการใช้งานที่เกิดขึ้น
• ใช้วิธีการของ onSaveInstanceState() เพื่อเก็บรักษาข้อมูลของแอปที่อาจสูญหายหากแอปปิดอยู่อย่างกะทันหัน เพิ่มโค้ดเพื่อคืนค่าข้อมูลดังกล่าวเมื่อแอปเริ่มทํางานอีกครั้ง

ใน Codelab นี้ ให้คุณขยายแอป DessertClicker จาก Codelab ก่อนหน้า เพิ่มตัวจับเวลาในเบื้องหลัง จากนั้นแปลงแอปเพื่อใช้ไลบรารีวงจรการใช้งาน Android

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

ขั้นตอนที่ 1: ตั้งค่าตัวจับเวลาส่วนตัว

1. เปิดแอป DessertClicker จาก Codelab ล่าสุด (คุณสามารถดาวน์โหลด DessertClickerLogs ที่นี่ หากยังไม่มีแอป)
2. ในมุมมองโปรเจ็กต์ ให้ขยาย java > com.example.android.dessertclicker แล้วเปิด DessertTimer.kt โปรดสังเกตว่าตอนนี้โค้ดทั้งหมดจะได้รับการแสดงความคิดเห็น โค้ดจึงไม่ได้เป็นส่วนหนึ่งของแอป
3. เลือกโค้ดทั้งหมดในหน้าต่างตัวแก้ไข เลือก Code > comment with Line comment หรือกด Control+/ (Command+/ บน Mac) คําสั่งนี้จะระบุโค้ดทั้งหมดในไฟล์ (Android Studio อาจแสดงข้อผิดพลาดอ้างอิงที่ยังไม่ได้แก้ไขจนกว่าคุณจะสร้างแอปอีกครั้ง)
4. โปรดทราบว่าชั้นเรียน DessertTimer มี startTimer() และ stopTimer() ซึ่งเริ่มและหยุดตัวจับเวลา เมื่อ startTimer() ทํางานอยู่ ตัวจับเวลาจะพิมพ์ข้อความในบันทึกทุกวินาที พร้อมจํานวนวินาทีทั้งหมดที่แสดงว่าตัวจับเวลาทํางานอยู่แล้ว และในทางกลับกัน เมธอด stopTimer() จะหยุดตัวจับเวลาและคําสั่งบันทึก
   

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

5. เปิด MainActivity.kt ที่ด้านบนของชั้นเรียน ใต้ตัวแปร dessertsSold ให้เพิ่มตัวแปรสําหรับตัวจับเวลา:
   

private lateinit var dessertTimer : DessertTimer;

6. เลื่อนลงไปที่ onCreate() และสร้างออบเจ็กต์ DessertTimer ใหม่หลังจากเรียกใช้ setOnClickListener():
   

dessertTimer = DessertTimer()

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

ขั้นตอนที่ 2: เริ่มและหยุดตัวจับเวลา

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

1. ในคลาส MainActivity ให้เริ่มตัวจับเวลาในการโทรกลับ onStart():
   

override fun onStart() {
   super.onStart()
   dessertTimer.startTimer()

   Timber.i("onStart called")
}

2. หยุดตัวจับเวลาใน onStop():
   

override fun onStop() {
   super.onStop()
   dessertTimer.stopTimer()

   Timber.i("onStop Called")
}

3. คอมไพล์และเรียกใช้แอป ใน Android Studio ให้คลิกแผง Logcat ในช่องค้นหาของ Logcat ให้ป้อน dessertclicker ซึ่งจะกรองตามทั้งชั้นเรียน MainActivity และ DessertTimer โปรดทราบว่าเมื่อแอปเริ่มทํางาน ตัวจับเวลาจะเริ่มทํางานทันที
   
4. คลิกปุ่มกลับและสังเกตเห็นว่าตัวจับเวลาหยุดอีกครั้ง ตัวจับเวลาหยุดทํางานเนื่องจากทั้งกิจกรรมและตัวจับเวลาที่ตัวควบคุมถูกทําลาย
5. ใช้หน้าจอล่าสุดเพื่อกลับไปที่แอป สังเกตใน Logcat ว่าตัวจับเวลาจะรีสตาร์ทจาก 0
6. คลิกปุ่มแชร์ โปรดทราบใน Logcat ว่าตัวจับเวลายังทํางานอยู่
   
   
7. คลิกปุ่มหน้าแรก สังเกตใน Logcat ว่าตัวจับเวลาจะหยุดทํางาน
8. ใช้หน้าจอล่าสุดเพื่อกลับไปที่แอป สังเกตใน Logcat ว่าตัวจับเวลาจะเริ่มต้นอีกครั้งจากจุดที่ค้างไว้
9. ใน MainActivity วิธีแสดงความคิดเห็นถึง onStop() ในวิธี stopTimer() การแสดงความคิดเห็นเกี่ยวกับ stopTimer() จะแสดงกรณีที่คุณเริ่มการดําเนินการใน onStart() แต่ลืมหยุดดําเนินการอีกครั้งใน onStop()
10. คอมไพล์และเรียกใช้แอป แล้วคลิกปุ่มหน้าแรกหลังจากที่ตัวจับเวลาเริ่มต้นแล้ว แม้ว่าแอปจะทํางานอยู่เบื้องหลัง แต่ตัวจับเวลาจะทํางานและใช้ทรัพยากรของระบบอย่างต่อเนื่อง การจับเวลาต่อไปจะทําให้หน่วยความจํารั่วของแอปและอาจเป็นลักษณะการทํางานที่ต้องการไม่ได้
    
    รูปแบบทั่วไปก็คือเมื่อตั้งค่าหรือเริ่มต้นโค้ดเรียกกลับ จะเป็นการหยุดหรือนําสิ่งดังกล่าวออกจากโค้ดเรียกกลับที่เกี่ยวข้อง วิธีนี้จะช่วยให้คุณไม่ต้องแสดงโฆษณาใดๆ เมื่อไม่จําเป็น

หมายเหตุ: ในบางกรณี เช่น การเล่นเพลง คุณก็ต้องทําให้สตรีมทํางานต่อไป มีวิธีที่เหมาะสมและมีประสิทธิภาพในการทํางานบางอย่าง แต่ให้อยู่นอกเหนือขอบเขตของบทเรียนนี้

11. เลิกยืนยันเส้นใน onStop() ที่คุณหยุดตัวจับเวลา
12. ตัดและวางสาย startTimer() จาก onStart() ไป onCreate() การเปลี่ยนแปลงนี้จะแสดงให้เห็นกรณีที่ทั้งเริ่มต้นและเริ่มใช้ทรัพยากรใน onCreate() แทนการใช้ onCreate() เพื่อเริ่มต้นและ onStart() เพื่อเริ่ม
13. คอมไพล์และเรียกใช้แอป โปรดสังเกตว่าตัวจับเวลาเริ่มทํางานตามที่คาดไว้
14. คลิกหน้าแรกเพื่อหยุดแอป ตัวจับเวลาจะหยุดทํางานตามที่คาดไว้
15. ใช้หน้าจอล่าสุดเพื่อกลับไปที่แอป โปรดสังเกตว่าตัวจับเวลาจะไม่เริ่มต้นอีกครั้งในกรณีนี้ เนื่องจาก onCreate() จะเรียกเฉพาะเมื่อแอปเริ่มทํางาน และจะไม่เรียกเมื่อแอปกลับสู่ส่วนหน้า

ประเด็นสําคัญที่ควรทราบมีดังนี้

• เมื่อคุณตั้งค่าทรัพยากรในการเรียกกลับของวงจร ให้แยกทรัพยากรออกด้วย
• โปรดดําเนินการตั้งค่าและลบออกด้วยวิธีที่เกี่ยวข้อง
• หากคุณตั้งค่าบางอย่างใน onStart() ให้หยุดหรือทําลายใหม่อีกครั้งใน onStop()
  
  

ในแอป DessertClicker จะเห็นได้ไม่ยากเลยว่า หากคุณเริ่มจับเวลาใน onStart() แล้ว คุณจะต้องหยุดตัวจับเวลาใน onStop() ตัวจับเวลามีแค่ครั้งเดียว การหยุดตัวจับเวลาจึงจําได้ยาก

ในแอป Android ที่ซับซ้อนมากขึ้น คุณอาจตั้งค่าหลายๆ อย่างใน onStart() หรือ onCreate() จากนั้นฉีกสัญญาณทุกอย่างใน onStop() หรือ onDestroy() ตัวอย่างเช่น คุณอาจมีภาพเคลื่อนไหว เพลง เซ็นเซอร์ หรือตัวจับเวลาที่ต้องทั้งตั้งค่าและขีดฆ่า แล้วเริ่มและหยุด หากลืม จะทําให้ข้อบกพร่องและปัญหาต่างๆ ปรากฏขึ้น

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

ไลบรารีอายุการใช้งานประกอบด้วย 3 ส่วนหลักดังนี้

• วงจร เจ้าของ ซึ่งเป็นองค์ประกอบที่มี (และ&&t ของตัวเอง)") วงจร Activity และ Fragment เป็นเจ้าของวงจรการใช้งาน เจ้าของอายุการใช้งานใช้อินเทอร์เฟซ LifecycleOwner
• คลาส Lifecycle ซึ่งเก็บสถานะจริงของเจ้าของอายุการใช้งานและทริกเกอร์เหตุการณ์เมื่อมีการเปลี่ยนแปลงวงจร
• การสังเกตการณ์วงจรซึ่งสังเกตสถานะอายุการใช้งานและดําเนินงานเมื่อวงจรมีการเปลี่ยนแปลง ผู้สังเกตการณ์วงจรการใช้งานใช้อินเทอร์เฟซ LifecycleObserver

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

ขั้นตอนที่ 1: เปลี่ยนตัวจับเวลาของหวานให้เป็น LifecycleObserver

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

1. เปิดชั้นเรียน DesertTimer.kt
2. เปลี่ยนลายเซ็นของชั้นเรียนของ DessertTimer ให้มีลักษณะดังนี้
   

class DessertTimer(lifecycle: Lifecycle) : LifecycleObserver {

คําจํากัดความคลาสใหม่นี้ทํา 2 สิ่งต่อไปนี้

• ตัวสร้างจะนําวัตถุ Lifecycle ซึ่งเป็นวงจรที่ตัวจับเวลากําลังสังเกตการณ์
• คําจํากัดความชั้นเรียนจะใช้อินเทอร์เฟซ LifecycleObserver

3. ใต้ตัวแปร runnable ให้เพิ่มบล็อก init ลงในคําจํากัดความของชั้นเรียน ในบล็อก init ให้ใช้เมธอด addObserver() เพื่อเชื่อมต่อออบเจ็กต์เกี่ยวกับอายุการใช้งานที่ส่งจากเจ้าของ (กิจกรรม) กับชั้นเรียนนี้ (ผู้สังเกตการณ์)
   

 init {
   lifecycle.addObserver(this)
}

4. ใส่คําอธิบายประกอบ startTimer() ด้วย @OnLifecycleEvent annotation และใช้เหตุการณ์ในวงจร ON_START เหตุการณ์ในวงจรทั้งหมดที่การสังเกตการณ์วงจรการใช้งานของคุณสังเกตได้จะอยู่ในคลาส Lifecycle.Event

@OnLifecycleEvent(Lifecycle.Event.ON_START)
fun startTimer() {

5. ทํากิจกรรมเดียวกันนี้กับ stopTimer() โดยใช้เหตุการณ์ ON_STOP ดังนี้

@OnLifecycleEvent(Lifecycle.Event.ON_STOP)
fun stopTimer()

ขั้นตอนที่ 2: แก้ไข MainActivity

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

1. เปิด MainActivity ในเมธอด onCreate() ให้แก้ไขการเริ่มต้นของ DessertTimer เพื่อรวม this.lifecycle

dessertTimer = DessertTimer(this.lifecycle)

พร็อพเพอร์ตี้ lifecycle ของกิจกรรมมีออบเจ็กต์ Lifecycle ที่กิจกรรมนี้เป็นเจ้าของ

2. นําการโทรออกไปยัง startTimer() ใน onCreate() และการโทรไปยัง stopTimer() ใน onStop() คุณไม่จําเป็นต้องแจ้งให้ DessertTimer ทราบว่าต้องทําอะไรในกิจกรรมอีกต่อไป เนื่องจาก DessertTimer กําลังดูวงจรการใช้งานของตัวเองอยู่ และจะได้รับการแจ้งเตือนโดยอัตโนมัติเมื่อสถานะวงจรเปลี่ยนแปลง สิ่งที่คุณต้องทําในการเรียกกลับเหล่านี้คือการบันทึกข้อความ
3. คอมไพล์และเรียกใช้แอป แล้วเปิด Logcat โปรดสังเกตว่าตัวจับเวลาเริ่มทํางานตามที่คาดไว้
4. คลิกปุ่มหน้าแรกเพื่อวางแอปในพื้นหลัง โปรดสังเกตว่าตัวจับเวลาหยุดทํางานตามที่คาดไว้

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

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

Android ควบคุมแอปพื้นหลังเพื่อให้แอปที่ทํางานอยู่เบื้องหน้าทํางานได้โดยไม่มีปัญหา เช่น Android จํากัดจํานวนการประมวลผลแอปที่ทํางานในเบื้องหลังได้

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

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

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

ขั้นตอนที่ 1: ใช้ adb เพื่อจําลองการปิดกระบวนการ

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

1. คอมไพล์และเรียกใช้แอป คลิกคัพเค้ก 2-3 ครั้ง
2. กดปุ่มหน้าแรกเพื่อให้แอปทํางานอยู่เบื้องหลัง ตอนนี้ระบบจะหยุดแอป และจะปิดแอปหาก Android ต้องใช้ทรัพยากรที่แอปใช้อยู่
3. ใน Android Studio ให้คลิกแท็บเทอร์มินัลเพื่อเปิดเทอร์มินัลบรรทัดคําสั่ง
4. พิมพ์ adb แล้วกด Return
   
   หากคุณเห็นเอาต์พุตจํานวนมากที่ขึ้นต้นด้วย Android Debug Bridge version X.XX.X และลงท้ายด้วย tags to be used by logcat (see logcat —help) ทุกอย่างก็ไม่มีปัญหา หากเห็น adb: command not found โปรดตรวจสอบว่ามีคําสั่ง adb ในเส้นทางการดําเนินการ ดูวิธีการได้ที่ "เพิ่ม adb ในเส้นทางการดําเนินการ" ในบทของยูทิลิตี
5. คัดลอกและวางความคิดเห็นนี้ลงในบรรทัดคําสั่ง แล้วกด Return:
   

adb shell am kill com.example.android.dessertclicker

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

6. ใช้หน้าจอล่าสุดเพื่อกลับไปที่แอป แอปของคุณจะปรากฏในแอปล่าสุด ไม่ว่าจะแสดงอยู่เบื้องหลังหรือเมื่อหยุดทํางานไปแล้วก็ตาม เมื่อใช้หน้าจอล่าสุดเพื่อกลับสู่แอป กิจกรรมจะเริ่มอีกครั้ง กิจกรรมจะเรียกใช้โค้ดเรียกกลับสําหรับวงจรของการเริ่มต้นทั้งหมด รวมถึง onCreate()
7. โปรดสังเกตว่าเมื่อรีสตาร์ทแอป แอปจะรีเซ็ต ""score" (ทั้งจํานวนขนมหวานที่ขายและจํานวนเงินทั้งหมด) เป็นค่าเริ่มต้น (0) หาก Android ปิดแอปของคุณไป เหตุใดแอปจึงไม่บันทึกสถานะของคุณ
   
   เมื่อระบบปฏิบัติการรีสตาร์ทแอปให้คุณ Android จะพยายามอย่างเต็มที่เพื่อรีเซ็ตแอปของคุณกลับสู่สถานะเดิม Android จะบันทึกยอดดูบางส่วนและบันทึกไว้ในกลุ่มทุกครั้งที่คุณออกจากกิจกรรม ตัวอย่างบางส่วนของข้อมูลที่บันทึกโดยอัตโนมัติจะเป็นข้อความใน EditText (ตราบใดที่มีการตั้งค่ารหัสในเลย์เอาต์) และสแต็กด้านหลังของกิจกรรม
   
   อย่างไรก็ตาม บางครั้งระบบปฏิบัติการ Android จะไม่ทราบข้อมูลทั้งหมด เช่น หากคุณมีตัวแปรที่กําหนดเองอย่าง revenue ในแอป DessertClicker ระบบปฏิบัติการ Android จะไม่ทราบเกี่ยวกับข้อมูลนี้หรือความสําคัญต่อกิจกรรมของคุณ คุณต้องเพิ่มข้อมูลนี้ไปยังกลุ่ม

ขั้นตอนที่ 2: ใช้ onSaveInstanceState() เพื่อบันทึกข้อมูลแพ็กเกจ

เมธอด onSaveInstanceState() คือโค้ดเรียกกลับที่คุณใช้เพื่อบันทึกข้อมูลที่คุณอาจต้องใช้หากระบบปฏิบัติการ Android ทําลายแอปของคุณ ในแผนภาพการติดต่อกลับตลอดอายุการใช้งาน ระบบจะเรียกใช้ onSaveInstanceState() หลังจากกิจกรรมหยุดลง โดยระบบจะเรียกใช้ฟีเจอร์นี้ทุกครั้งที่แอปทํางานอยู่เบื้องหลัง

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

1. ใน MainActivity ให้ลบล้างโค้ดเรียกกลับ onSaveInstanceState() และเพิ่มคําสั่งบันทึก Timber
   

override fun onSaveInstanceState(outState: Bundle) {
   super.onSaveInstanceState(outState)

   Timber.i("onSaveInstanceState Called")
}

หมายเหตุ: มีการลบล้างสําหรับ onSaveInstanceState() อยู่ 2 รายการ รายการหนึ่งมีพารามิเตอร์ outState รายการเท่านั้น และรายการใหม่มีพารามิเตอร์ outState และ outPersistentState ใช้ URL ที่แสดงในโค้ดด้านบนโดยมีพารามิเตอร์ outState รายการเดียว

2. คอมไพล์และเรียกใช้แอป แล้วคลิกปุ่มหน้าแรกเพื่อวางลงในพื้นหลัง โปรดทราบว่าโค้ดเรียกกลับ onSaveInstanceState() จะเกิดขึ้นหลัง onPause() และ onStop() ดังนี้
   
3. เพิ่มค่าคงที่ต่อไปนี้ไว้ที่ด้านบนสุดของไฟล์

const val KEY_REVENUE = "revenue_key"
const val KEY_DESSERT_SOLD = "dessert_sold_key"
const val KEY_TIMER_SECONDS = "timer_seconds_key"

คุณจะใช้คีย์เหล่านี้สําหรับทั้งการบันทึกและเรียกข้อมูลจากชุดสถานะอินสแตนซ์

4. เลื่อนลงไปที่ onSaveInstanceState() แล้วสังเกตพารามิเตอร์ outState ซึ่งเป็นประเภท Bundle
   
   กลุ่มคือชุดคู่คีย์-ค่าที่มีคีย์เป็นสตริงเสมอ คุณจะป้อนค่าพื้นฐาน เช่น ค่า int และ boolean ลงในกลุ่มได้
   เนื่องจากระบบจะจัดเก็บแพ็กเกจนี้ไว้ใน RAM แนวทางปฏิบัติที่ดีที่สุดจึงเป็นการเก็บรวบรวมข้อมูลในกลุ่มเล็ก ขนาดของ Bundle นี้ยังจํากัด แม้ว่าขนาดจะแตกต่างกันไปในแต่ละอุปกรณ์ โดยปกติแล้วคุณควรจัดเก็บข้อมูลไว้น้อยกว่า 100, 000 ครั้ง มิฉะนั้นอาจทําให้แอปขัดข้องโดยมีข้อผิดพลาด TransactionTooLargeException
   
5. ใน onSaveInstanceState() ให้ใส่ค่า revenue (จํานวนเต็ม) ในแพ็กเกจโดยใช้เมธอด putInt() ดังนี้
   

outState.putInt(KEY_REVENUE, revenue)

เมธอด putInt() (และวิธีการที่คล้ายกันจากคลาส Bundle เช่น putFloat() และ putString() ใช้อาร์กิวเมนต์ 2 รายการ ได้แก่ สตริงสําหรับคีย์ (ค่าคงที่ KEY_REVENUE) และค่าจริงที่จะบันทึก

6. ทําขั้นตอนเดียวกันอีกครั้งกับจํานวนขนมหวานที่ขาย และสถานะของตัวจับเวลา

outState.putInt(KEY_DESSERT_SOLD, dessertsSold)
outState.putInt(KEY_TIMER_SECONDS, dessertTimer.secondsCount)

ขั้นตอนที่ 3: ใช้ onCreate() เพื่อคืนค่าข้อมูลแพ็กเกจ

1. เลื่อนไปที่ onCreate() และตรวจสอบลายเซ็นของวิธีการ:

override fun onCreate(savedInstanceState: Bundle) {

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

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

2. เพิ่มโค้ดนี้ลงใน onCreate() หลังจากการตั้งค่า DessertTimer:
   

if (savedInstanceState != null) {
   revenue = savedInstanceState.getInt(KEY_REVENUE, 0)
}

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

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

• สตริงที่ทําหน้าที่เป็นคีย์ เช่น "key_revenue" สําหรับค่ารายได้
• ค่าเริ่มต้นในกรณีที่ไม่มีค่าสําหรับคีย์นั้นในแพ็กเกจ

จากนั้นระบบจะกําหนดจํานวนเต็มที่ได้รับจากแพ็กเกจให้กับตัวแปร revenue และ UI จะใช้ค่านั้น

3. เพิ่ม getInt() วิธีการกู้คืนจํานวนขนมหวานที่ขายและค่าของตัวจับเวลา

if (savedInstanceState != null) {
   revenue = savedInstanceState.getInt(KEY_REVENUE, 0)dessertsSold = savedInstanceState.getInt(KEY_DESSERT_SOLD, 0)
   dessertTimer.secondsCount =
       savedInstanceState.getInt(KEY_TIMER_SECONDS, 0)
}

4. คอมไพล์และเรียกใช้แอป กดคัพเค้กอย่างน้อย 5 ครั้งจนกว่าจะเปลี่ยนเป็นโดนัท คลิก "หน้าแรก" เพื่อวางแอปในเบื้องหลัง
5. ในแท็บเทอร์มินัลของ Android Studio ให้เรียกใช้ adb เพื่อปิดกระบวนการของแอป
   

adb shell am kill com.example.android.dessertclicker

6. ใช้หน้าจอล่าสุดเพื่อกลับไปที่แอป โปรดทราบว่าตอนนี้แอปจะส่งคืนพร้อมรายได้ที่ถูกต้องและของหวานที่ขายจากแพ็กเกจ แต่ก็สังเกตด้วยว่าขนมหวานส่งกลับไปที่คัพเค้ก เหลืออีกเพียง 1 อย่างเพื่อให้แน่ใจว่าแอปจะกลับสู่สถานะเดิมหลังการปิดตัว
7. ใน MainActivity ให้ตรวจสอบเมธอด showCurrentDessert() สังเกตได้ว่าวิธีนี้จะเป็นตัวกําหนดภาพของขนมหวานที่จะแสดงในกิจกรรมตามจํานวนของหวานที่ขายในปัจจุบันและรายการขนมหวานในตัวแปร allDesserts
   

for (dessert in allDesserts) {
   if (dessertsSold >= dessert.startProductionAmount) {
       newDessert = dessert
   }
    else break
}

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

8. ใน onCreate() ในบล็อกที่คืนค่าสถานะจากแพ็กเกจ ให้เรียกใช้ showCurrentDessert():
   

 if (savedInstanceState != null) {
   revenue = savedInstanceState.getInt(KEY_REVENUE, 0)
   dessertsSold = savedInstanceState.getInt(KEY_DESSERT_SOLD, 0)
   dessertTimer.secondsCount = 
      savedInstanceState.getInt(KEY_TIMER_SECONDS, 0)
   showCurrentDessert()                   
}

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

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

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

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

1. คอมไพล์และเรียกใช้แอป แล้วเปิด Logcat
2. หมุนอุปกรณ์หรือโปรแกรมจําลองเป็นโหมดแนวนอน คุณสามารถหมุนโปรแกรมจําลองไปทางซ้ายหรือขวาด้วยปุ่มหมุน หรือใช้แป้น Control และแป้นลูกศร (Command และแป้นลูกศรใน Mac)
   
3. ตรวจสอบผลลัพธ์ใน Logcat กรองเอาต์พุตใน MainActivity
   โปรดทราบว่าเมื่ออุปกรณ์หรือโปรแกรมจําลองหมุนหน้าจอแล้ว ระบบจะเรียกใช้โค้ดเรียกกลับตลอดอายุการใช้งานเพื่อปิดระบบกิจกรรมดังกล่าว จากนั้น เมื่อมีการสร้างกิจกรรมอีกครั้ง ระบบจะเรียกใช้โค้ดเรียกกลับตลอดอายุการใช้งานทั้งหมดเพื่อเริ่มกิจกรรม
4. ใน MainActivity ให้แสดงความคิดเห็นเกี่ยวกับวิธี onSaveInstanceState() ทั้งหมด
5. คอมไพล์และเรียกใช้แอปอีกครั้ง คลิกคัพเค้ก 2-3 ครั้งแล้วหมุนอุปกรณ์หรือโปรแกรมจําลอง ในช่วงเวลานี้เมื่อหมุนอุปกรณ์และปิดกิจกรรม แล้วสร้างใหม่ กิจกรรมจะเริ่มต้นด้วยค่าเริ่มต้น
   
   เมื่อมีการเปลี่ยนแปลงการกําหนดค่า Android จะใช้กลุ่มสถานะอินสแตนซ์เดียวกันกับที่คุณเรียนรู้ในงานก่อนหน้าเพื่อบันทึกและกู้คืนสถานะของแอป เมื่อใช้ onSaveInstanceState() ซึ่งเป็นการปิดกระบวนการ ให้ใช้ onSaveInstanceState() เพื่อรวมข้อมูลของแอปลงในกลุ่ม จากนั้นกู้คืนข้อมูลใน onCreate() เพื่อไม่ให้ข้อมูลสถานะกิจกรรมสูญหายหากหมุนอุปกรณ์
6. ใน MainActivity ให้ยกเลิกการแสดงความคิดเห็นเกี่ยวกับวิธี onSaveInstanceState() เรียกใช้แอป คลิกคัพเค้ก และหมุนแอปหรืออุปกรณ์ สังเกตได้ว่าข้อมูลขนมหวานจะถูกเก็บไว้ในการหมุนเวียนกิจกรรม

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

เคล็ดลับในการใช้ชีวิต

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

ไลบรารีอายุการใช้งาน

• ใช้ไลบรารีวงจรการใช้งาน Android เพื่อเปลี่ยนการควบคุมวงจรการใช้งานจากกิจกรรมหรือส่วนย่อยไปเป็นคอมโพเนนต์จริงที่จําเป็นต้องคํานึงถึงวงจร
• เจ้าของวงจรคือคอมโพเนนต์ที่มี (และ &&tt ของตัวเอง &&tt;) วงจร ซึ่งรวมถึง Activity และ Fragment เจ้าของอายุการใช้งานใช้อินเทอร์เฟซ LifecycleOwner
• ผู้สังเกตการณ์วงจรการใช้งานจะให้ความสําคัญกับสถานะปัจจุบันในวงจรและทํางานต่างๆ เมื่อวงจรการใช้งานมีการเปลี่ยนแปลง ผู้สังเกตการณ์วงจรการใช้งานใช้อินเทอร์เฟซ LifecycleObserver
• ออบเจ็กต์ Lifecycle มีสถานะอายุการใช้งานจริงและจะทริกเกอร์เหตุการณ์เมื่ออายุการใช้งานมีการเปลี่ยนแปลง

วิธีสร้างชั้นเรียนตามวงจรการใช้งาน

• ใช้อินเทอร์เฟซ LifecycleObserver ในชั้นเรียนที่ต้องคํานึงถึงวงจรการใช้งาน
• เริ่มต้นคลาสผู้สังเกตการณ์อายุการใช้งานด้วยออบเจ็กต์อายุการใช้งานจากกิจกรรมหรือส่วนย่อย
• ในชั้นเรียนการสังเกตการณ์วงจรการใช้งาน ให้ใส่คําอธิบายประกอบในวงจรที่รับรู้ถึงวงจรด้วยการเปลี่ยนแปลงสถานะวงจรที่สนใจ
  
  ตัวอย่างเช่น @OnLifecycleEvent(Lifecycle.Event.ON_START)หมายเหตุจะแสดงว่าเมธอดกําลังรับชมเหตุการณ์ในวงจรonStartเหตุการณ์

ดําเนินการปิดเครื่องและบันทึกกิจกรรม

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

การเก็บรักษากิจกรรมและสถานะส่วนย่อย

• เมื่อแอปทํางานอยู่ในเบื้องหลัง หลักจากเรียกใช้ onStop() แล้ว ระบบจะบันทึกข้อมูลแอปไปยังกลุ่ม ข้อมูลแอปบางอย่าง เช่น เนื้อหาของ EditText จะได้รับการบันทึกไว้โดยอัตโนมัติ
• แพ็กเกจนี้เป็นอินสแตนซ์ของ Bundle ซึ่งเป็นคอลเล็กชันคีย์และค่า คีย์จะเป็นสตริงเสมอ
• ใช้โค้ดเรียกกลับ onSaveInstanceState() เพื่อบันทึกข้อมูลอื่นๆ ไปยัง Bundle ที่ต้องการเก็บไว้ แม้ว่าแอปจะปิดโดยอัตโนมัติก็ตาม หากต้องการรวมข้อมูลไว้ในแพ็กเกจ ให้ใช้เมธอดของแพ็กเกจที่ขึ้นต้นด้วย put เช่น putInt()
• คุณจะนําข้อมูลออกจากแพ็กเกจได้โดยใช้เมธอด onRestoreInstanceState() หรือบ่อยกว่าใน onCreate() เมธอด onCreate() มีพารามิเตอร์ savedInstanceState ที่เก็บกลุ่ม
• หากตัวแปร savedInstanceState มี null กิจกรรมจะเริ่มต้นโดยไม่มีกลุ่มรัฐและไม่มีข้อมูลสถานะที่จะเรียก
• หากต้องการดึงข้อมูลจากแพ็กเกจด้วยคีย์ ให้ใช้เมธอด Bundle ที่ขึ้นต้นด้วย get เช่น getInt()

การเปลี่ยนแปลงการกําหนดค่า

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

หลักสูตร Udacity:

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

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

• กิจกรรม (คําแนะนําเกี่ยวกับ API)
• Activity (เอกสารอ้างอิง API)
• ทําความเข้าใจวงจรการใช้งานกิจกรรม
• การจัดการวงจรการใช้งานด้วยคอมโพเนนต์การรับรู้วงจรการใช้งาน
• LifecycleOwner
• Lifecycle
• LifecycleObserver
• onSaveInstanceState()
• จัดการการเปลี่ยนแปลงการกําหนดค่า
• การบันทึกสถานะ UI

อื่นๆ:

• Timber (GitHub)

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

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

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

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

เปลี่ยนแอป

เปิดแอป DiceRoller จากบทเรียนที่ 1 (หากไม่มี ให้ดาวน์โหลดแอปที่นี่) คอมไพล์และเรียกใช้แอปและโปรดทราบว่าหากหมุนอุปกรณ์ ค่าลูกเต๋าปัจจุบันจะหายไป ใช้ onSaveInstanceState() เพื่อคงค่านั้นในแพ็กเกจและกู้คืนค่านั้นใน onCreate()

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

คำถามที่ 1

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

• ในระหว่างการโทร คุณควรคํานวณตําแหน่งของวัตถุในการจําลองฟิสิกส์ต่อ
• ระหว่างการโทร คุณควรหยุดคํานวณตําแหน่งของวัตถุในการจําลองฟิสิกส์

คำถามที่ 2

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

• onDestroy()
• onStop()
• onPause()
• onSaveInstanceState()

คำถามที่ 3

หากต้องการจดจําวงจรชีวิตผ่านไลบรารี Android Lifecycle ชั้นเรียนควรจะใช้อินเทอร์เฟซใด

• Lifecycle
• LifecycleOwner
• Lifecycle.Event
• LifecycleObserver

คำถามที่ 4

ในสถานการณ์ใด เมธอด onCreate() ในกิจกรรมของคุณจะได้รับ Bundle ที่มีข้อมูลในนั้น (กล่าวคือ Bundle ไม่ใช่ null) อาจมีคําตอบมากกว่า 1 ข้อ

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

เริ่มบทเรียนถัดไป: 5.1: Viewmodel และ ViewModelFactory

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