lifecycleScope — คืออะไร การเชื่อมโยงกับ Lifecycle และการทำงานใน Android

lifecycleScope ใน Android คืออะไร?

lifecycleScope เป็นคุณสมบัติส่วนขยายบนอินเทอร์เฟซ LifecycleOwner (Activity, Fragment, Service) ที่ให้ CoroutineScope พร้อมใช้ เชื่อมโยงกับวงจรชีวิตทั้งหมดของคอมโพเนนต์ เมื่อ LifecycleOwner ถึงสถานะ DESTROYED lifecycleScope จะยกเลิก coroutine ที่ทำงานอยู่ทั้งหมดโดยอัตโนมัติ

// In Fragment or Activity
lifecycleScope.launch {
    delay(1000)
    showSnackbar("สวัสดี!")
}

แตกต่างจาก viewModelScope ตรงที่ lifecycleScope จะถูกยกเลิกทุกครั้งที่ LifecycleOwner ถูกทำลาย — รวมถึงการหมุนหน้าจอ ทำให้เหมาะสำหรับการดำเนินการที่ควรมีชีวิตอยู่เฉพาะเมื่อหน้าจอเฉพาะกำลังแสดงอยู่

สถานที่ที่ lifecycleScope พร้อมใช้งาน

lifecycleScope พร้อมใช้งานทุกที่มี LifecycleOwner:

• Activity — AppCompatActivity สืบทอด LifecycleOwner
• Fragment — Fragment สืบทอด LifecycleOwner
• LifecycleService — บริการที่มีวงจรชีวิต
• ProcessLifecycleOwner — วงจรชีวิตของทั้งแอปพลิเคชัน
• LifecycleOwner ที่กำหนดเอง — วัตถุใดๆ ที่ใช้ LifecycleOwner

lifecycleScope ทำงานอย่างไร: Lifecycle และการยกเลิกอัตโนมัติ

กลไกการยกเลิกอัตโนมัติของ lifecycleScope ขึ้นอยู่กับการสมัครรับเหตุการณ์ Lifecycle เมื่อ Lifecycle ลดลงต่ำกว่า CREATED ไปยัง DESTROYED scope จะถูกยกเลิก

สถานะของ Lifecycle

โครงสร้างภายในของ lifecycleScope

lifecycleScope ถูกสร้างขึ้นเป็น CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate) และจัดเก็บภายใน Lifecycle เมื่อ Lifecycle เปลี่ยนไปเป็นสถานะ DESTROYED จะเรียก scope.cancel() กลไกนี้ถูกใช้งานผ่าน LifecycleEventObserver ซึ่งสมัครรับเหตุการณ์วงจรชีวิตเมื่อเข้าถึง scope ครั้งแรก

พฤติกรรมเมื่อหมุน

เมื่อหมุนหน้าจอ Activity จะถูกทำลาย (onDestroy) และสร้างใหม่ lifecycleScope จะถูกยกเลิกพร้อมกับ Activity เก่า และอินสแตนซ์ scope ใหม่จะถูกสร้างขึ้นสำหรับ Activity ใหม่ นี่คือความแตกต่างพื้นฐานจาก viewModelScope ซึ่งคงอยู่เมื่อหมุน

API ของ lifecycleScope: launch, launchWhen และ repeatOnLifecycle

ไลบรารี lifecycle มีหลายวิธีในการเริ่ม coroutine ผ่าน lifecycleScope มาดูวิวัฒนาการของ API จากเมธอดที่เลิกใช้แล้วไปจนถึงสมัยใหม่

lifecycleScope.launch — การเริ่มต้นพื้นฐาน

วิธีที่ง่ายที่สุดคือ lifecycleScope.launch { ... } coroutine เริ่มต้นทันทีและถูกยกเลิกที่ DESTROYED อย่างไรก็ตาม มันสามารถเรียกใช้โค้ดได้แม้เมื่อ UI ไม่ปรากฏ (เช่น ในพื้นหลังหลังจาก onStop) ซึ่งไม่เป็นที่ต้องการเสมอไป

เมธอดที่เลิกใช้แล้ว: launchWhenCreated / launchWhenStarted / launchWhenResumed

เมธอดเหล่านี้จะหยุดการทำงานของ coroutine ชั่วคราวเมื่อ Lifecycle ลดลงต่ำกว่าสถานะที่ระบุ และดำเนินการต่อเมื่อกลับมา อย่างไรก็ตาม พวกมันถูกทำเครื่องหมายเป็น @Deprecated ใน lifecycle-runtime-ktx 2.6.0 เพราะ:

• พวกมันไม่ยกเลิก coroutine — แค่หยุดชั่วคราว
• พวกมันทำให้เกิดการสะสมของ coroutine ที่ถูกระงับซึ่งกินหน่วยความจำ
• พวกมันสร้างสภาวะการแข่งขันเมื่อเปลี่ยนสถานะอย่างรวดเร็ว

API ที่ทันสมัย: repeatOnLifecycle

repeatOnLifecycle เป็นวิธีที่ Google แนะนำในการเริ่ม coroutine ที่ซิงค์กับวงจรชีวิต มันยกเลิกและเริ่ม coroutine ใหม่ทุกครั้งที่ Lifecycle ถึงสถานะที่ระบุ

lifecycleScope.launch {
    repeatOnLifecycle(Lifecycle.State.STARTED) {
        viewModel.uiState.collect { state ->
            updateUI(state)
        }
    }
}

coroutine ที่ส่งไปยัง repeatOnLifecycle จะเริ่มเมื่อ Lifecycle ถึง STARTED และจะถูกยกเลิกเมื่อลดลงต่ำกว่า STARTED เมื่อกลับสู่ STARTED coroutine จะเริ่มต้นใหม่ตั้งแต่ต้น ปลอดภัยและมีประสิทธิภาพ — ไม่มี coroutine ใดถูกระงับค้างอยู่

flowWithLifecycle — สำหรับ Flow

สำหรับการรวบรวมข้อมูลจาก Flow โดยรับรู้วงจรชีวิต มีโอเปอเรเตอร์ flowWithLifecycle ซึ่งจะหยุดและเริ่มการรวบรวมโดยอัตโนมัติเมื่อสถานะ Lifecycle เปลี่ยนแปลง:

viewModel.uiState
    .flowWithLifecycle(lifecycle, Lifecycle.State.STARTED)
    .onEach { state -> updateUI(state) }
    .launchIn(lifecycleScope)

โอเปอเรเตอร์ flowWithLifecycle เป็นวิธีที่สั้นที่สุดในการสมัครรับ Flow อย่างปลอดภัยในเลเยอร์ UI

ตัวอย่างการใช้งาน lifecycleScope

มาดูสามสถานการณ์จริงของการใช้ lifecycleScope ในแอปพลิเคชัน Android ด้วย Kotlin

ตัวอย่างที่ 1: สมัครรับการอัปเดตตำแหน่งเฉพาะเมื่อหน้าจอมองเห็น

class MapFragment : Fragment() {

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)

        lifecycleScope.launch {
            repeatOnLifecycle(Lifecycle.State.STARTED) {
                locationProvider.observeLocation().collect { loc ->
                    updateMapMarker(loc)
                }
            }
        }
    }
}

coroutine เริ่มเมื่อ fragment ปรากฏ (STARTED) และถูกยกเลิกเมื่อออกจากหน้าจอ (STOPPED) หากผู้ใช้เปลี่ยนไปใช้แอปอื่น การอัปเดตตำแหน่งจะไม่กินแบตเตอรี่

ตัวอย่างที่ 2: เริ่มแอนิเมชันเมื่อ fragment เริ่ม

lifecycleScope.launch {
    repeatOnLifecycle(Lifecycle.State.RESUMED) {
        animateFadeIn(titleView)
        delay(200)
        animateSlideUp(contentView)
    }
}

แอนิเมชันจะทำงานเมื่อ fragment อยู่ในเบื้องหน้าเท่านั้น (RESUMED) หากผู้ใช้ย่อแอประหว่างแอนิเมชัน coroutine จะถูกยกเลิก และเมื่อกลับมา แอนิเมชันจะเริ่มใหม่

ตัวอย่างที่ 3: การซิงค์ข้อมูลเป็นระยะบนหน้าจอที่มองเห็น

lifecycleScope.launch {
    repeatOnLifecycle(Lifecycle.State.STARTED) {
        while (isActive) {
            syncData()
            delay(30_000L)
        }
    }
}

ข้อมูลจะถูกซิงค์ทุก 30 วินาที แต่เฉพาะเมื่อหน้าจอมองเห็น isActive ตรวจสอบว่า coroutine ถูกยกเลิกหรือไม่ ซึ่งเป็นวิธีที่ปลอดภัยในการออกจากลูปเมื่อออกจากหน้าจอ

lifecycleScope กับ viewModelScope: สถานการณ์การใช้งาน

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

ความแตกต่างหลัก

viewModelScope เชื่อมโยงกับ ViewModel ซึ่งคงอยู่เมื่อหมุนหน้าจอ lifecycleScope เชื่อมโยงกับ LifecycleOwner (Activity/Fragment) ซึ่งถูกทำลายและสร้างใหม่เมื่อหมุน สิ่งนี้กำหนดสถานการณ์การใช้งาน

เมื่อใดควรใช้ lifecycleScope

• สมัครรับเหตุการณ์ระบบ (ตำแหน่ง, เซ็นเซอร์, กล้อง)
• แอนิเมชันและเอฟเฟกต์ UI ที่เชื่อมโยงกับหน้าจอเฉพาะ
• การโหลดข้อมูลเป็นชิ้นตามการมองเห็นของหน้าจอ
• การดำเนินการที่ควรหยุดเมื่อออกจากหน้าจอ

เมื่อใดควรใช้ viewModelScope

• การโหลดข้อมูลจาก Repository
• ตรรกะทางธุรกิจที่ควรคงอยู่เมื่อหมุน
• การแคชและการประมวลผลข้อมูล
• การดำเนินการใดๆ ที่ต้องการผลลัพธ์หลังการหมุน

การใช้ร่วมกัน

ในทางปฏิบัติ การรวมกันของทั้งสอง scope เป็นเรื่องปกติ: viewModelScope โหลดข้อมูลและจัดการสถานะ ในขณะที่ lifecycleScope สมัครรับ Flow จาก ViewModel โดยรับรู้วงจรชีวิต การแยกความรับผิดชอบนี้ถือเป็น แนวปฏิบัติที่ดีที่สุด ในการพัฒนา Android สมัยใหม่

ข้อผิดพลาดทั่วไปเมื่อทำงานกับ lifecycleScope

มาดูสี่ข้อผิดพลาดทั่วไปที่นักพัฒนาทำเมื่อใช้ lifecycleScope

ข้อผิดพลาด 1: ใช้ lifecycleScope แทน viewModelScope สำหรับการโหลดข้อมูล

หากคุณเริ่มการโหลดข้อมูลใน lifecycleScope.launch coroutine จะถูกยกเลิกเมื่อหมุนหน้าจอและข้อมูลจะต้องโหลดใหม่ ใช้ viewModelScope สำหรับการดำเนินการที่อายุยืน lifecycleScope มีไว้สำหรับงานที่เชื่อมโยงกับ UI เท่านั้น

ข้อผิดพลาด 2: รวบรวม Flow โดยไม่มี repeatOnLifecycle

การเรียก viewModel.someFlow.collect { ... } โดยตรงภายใน lifecycleScope.launch จะยังคงรวบรวมข้อมูลต่อไปแม้เมื่อหน้าจอไม่ปรากฏ สิ่งนี้อาจทำให้เกิดการอัปเดต UI ในพื้นหลังและค่าใช้จ่ายที่ไม่จำเป็น ใช้ repeatOnLifecycle หรือ flowWithLifecycle เสมอ

ข้อผิดพลาด 3: ลืมยกเลิกเมื่อออกจากหน้าจอ

แม้ว่า lifecycleScope จะถูกยกเลิกที่ DESTROYED แต่โค้ดหลังจากจุดระงับ (suspend) อาจไม่ทำงานเมื่อถูกยกเลิกกะทันหัน อย่าพึ่งพาการทำงานของโค้ดหลังจากการเรียก suspend เว้นแต่คุณจะใช้ NonCancellable

ข้อผิดพลาด 4: ใช้ launchWhenStarted ที่เลิกใช้แล้วแทน repeatOnLifecycle

launchWhenStarted และสิ่งที่คล้ายกันไม่ยกเลิก coroutine แค่หยุดชั่วคราว หากหน้าจอสลับระหว่างเบื้องหน้าและพื้นหลังหลายครั้ง coroutine จะสะสมการเรียกที่ถูกเลื่อน เปลี่ยนไปใช้ repeatOnLifecycle — นี่เป็นวิธีที่ถูกต้องเท่านั้นในการซิงค์กับ Lifecycle