แนวคิดและการใช้งาน Jetpack Compose
คอมโพเนนต์ที่รับรู้วงจรจะดำเนินการเพื่อตอบสนองต่อการเปลี่ยนแปลงสถานะวงจรของคอมโพเนนต์อื่น เช่น กิจกรรมและส่วนย่อย คอมโพเนนต์เหล่านี้ช่วยให้คุณสร้างโค้ดที่มีการจัดระเบียบได้ดีขึ้นและมักจะมีขนาดเล็กลง ซึ่งทำให้ดูแลรักษาได้ง่ายขึ้น
รูปแบบที่พบบ่อยคือการใช้การดำเนินการของคอมโพเนนต์ที่ขึ้นต่อกันในเมธอดวงจรของกิจกรรมและ Fragment อย่างไรก็ตาม รูปแบบนี้ทำให้การจัดระเบียบโค้ดไม่ดีและทำให้เกิดข้อผิดพลาดเพิ่มขึ้น การใช้คอมโพเนนต์ที่รับรู้ถึงวงจรชีวิตจะช่วยให้คุณย้ายโค้ดของคอมโพเนนต์ที่ขึ้นต่อกันออกจากเมธอดวงจรชีวิตและเข้าไปในคอมโพเนนต์เองได้
แพ็กเกจ androidx.lifecycle มีคลาสและอินเทอร์เฟซที่ช่วยให้คุณสร้างคอมโพเนนต์ที่รับรู้ถึงวงจร ซึ่งเป็นคอมโพเนนต์ที่สามารถปรับลักษณะการทำงานโดยอัตโนมัติตามสถานะวงจรปัจจุบันของกิจกรรมหรือ Fragment
คอมโพเนนต์แอปส่วนใหญ่ที่กำหนดไว้ในเฟรมเวิร์ก Android มีวงจรที่เชื่อมโยงอยู่ด้วย วงจรได้รับการจัดการโดยระบบปฏิบัติการหรือโค้ดเฟรมเวิร์กที่ทำงานในกระบวนการของคุณ ซึ่งเป็นหัวใจสำคัญของการทำงานของ Android และแอปพลิเคชันของคุณต้องปฏิบัติตามสิทธิ์เหล่านั้น การไม่ดำเนินการดังกล่าวอาจทำให้หน่วยความจำรั่วไหลหรือแม้แต่แอปพลิเคชันขัดข้อง
สมมติว่าเรามีกิจกรรมที่แสดงตำแหน่งของอุปกรณ์บนหน้าจอ การติดตั้งใช้งานทั่วไปอาจมีลักษณะดังนี้
Kotlin
internal class MyLocationListener(
private val context: Context,
private val callback: (Location) -> Unit
) {
fun start() {
// connect to system location service
}
fun stop() {
// disconnect from system location service
}
}
class MyActivity : AppCompatActivity() {
private lateinit var myLocationListener: MyLocationListener
override fun onCreate(...) {
myLocationListener = MyLocationListener(this) { location ->
// update UI
}
}
public override fun onStart() {
super.onStart()
myLocationListener.start()
// manage other components that need to respond
// to the activity lifecycle
}
public override fun onStop() {
super.onStop()
myLocationListener.stop()
// manage other components that need to respond
// to the activity lifecycle
}
}
Java
class MyLocationListener {
public MyLocationListener(Context context, Callback callback) {
// ...
}
void start() {
// connect to system location service
}
void stop() {
// disconnect from system location service
}
}
class MyActivity extends AppCompatActivity {
private MyLocationListener myLocationListener;
@Override
public void onCreate(...) {
myLocationListener = new MyLocationListener(this, (location) -> {
// update UI
});
}
@Override
public void onStart() {
super.onStart();
myLocationListener.start();
// manage other components that need to respond
// to the activity lifecycle
}
@Override
public void onStop() {
super.onStop();
myLocationListener.stop();
// manage other components that need to respond
// to the activity lifecycle
}
}
แม้ว่าตัวอย่างนี้จะดูดี แต่ในแอปจริง คุณอาจต้องมีการเรียกใช้จำนวนมากเกินไปเพื่อจัดการ UI และคอมโพเนนต์อื่นๆ เพื่อตอบสนองต่อสถานะปัจจุบันของวงจร การจัดการคอมโพเนนต์หลายรายการจะทำให้มีโค้ดจำนวนมากในเมธอดวงจร เช่น onStart() และ onStop ซึ่งทำให้ดูแลรักษาได้ยาก
นอกจากนี้ ยังไม่มีการรับประกันว่าคอมโพเนนต์จะเริ่มทำงานก่อนที่กิจกรรมหรือส่วนย่อยจะหยุดลง โดยเฉพาะอย่างยิ่งหากเราต้องดำเนินการที่ใช้เวลานาน เช่น การตรวจสอบการกำหนดค่าบางอย่างใน onStart ซึ่งอาจทำให้เกิดภาวะแข่งขันที่เมธอด onStop() ทำงานเสร็จก่อน onStart ทำให้คอมโพเนนต์ทำงานนานเกินความจำเป็น
Kotlin
class MyActivity : AppCompatActivity() {
private lateinit var myLocationListener: MyLocationListener
override fun onCreate(...) {
myLocationListener = MyLocationListener(this) { location ->
// update UI
}
}
public override fun onStart() {
super.onStart()
Util.checkUserStatus { result ->
// what if this callback is invoked AFTER activity is stopped?
if (result) {
myLocationListener.start()
}
}
}
public override fun onStop() {
super.onStop()
myLocationListener.stop()
}
}
Java
class MyActivity extends AppCompatActivity {
private MyLocationListener myLocationListener;
public void onCreate(...) {
myLocationListener = new MyLocationListener(this, location -> {
// update UI
});
}
@Override
public void onStart() {
super.onStart();
Util.checkUserStatus(result -> {
// what if this callback is invoked AFTER activity is stopped?
if (result) {
myLocationListener.start();
}
});
}
@Override
public void onStop() {
super.onStop();
myLocationListener.stop();
}
}
แพ็กเกจ androidx.lifecycle มีคลาสและอินเทอร์เฟซที่ช่วยให้คุณจัดการปัญหาเหล่านี้ได้อย่างยืดหยุ่นและแยกต่างหาก
อายุการใช้งาน
Lifecycle เป็นคลาสที่เก็บข้อมูลเกี่ยวกับสถานะวงจรของคอมโพเนนต์ (เช่น กิจกรรมหรือ Fragment) และอนุญาตให้ออบเจ็กต์อื่นๆ สังเกตสถานะนี้ได้
Lifecycle ใช้การแจงนับหลัก 2 รายการเพื่อติดตามสถานะวงจรของคอมโพเนนต์ที่เกี่ยวข้อง ดังนี้
กิจกรรม
เหตุการณ์ในวงจรที่ส่งมาจากเฟรมเวิร์กและคลาส Lifecycle เหตุการณ์เหล่านี้จะแมปกับเหตุการณ์ Callback ในกิจกรรมและ Fragment
รัฐ
สถานะปัจจุบันของคอมโพเนนต์ที่ติดตามโดยออบเจ็กต์ Lifecycle
ให้คิดว่าสถานะเป็นโหนดของกราฟและเหตุการณ์เป็นขอบระหว่างโหนดเหล่านี้
คลาสสามารถตรวจสอบสถานะวงจรของคอมโพเนนต์ได้โดยใช้ DefaultLifecycleObserver และลบล้างเมธอดที่เกี่ยวข้อง เช่น onCreate, onStart เป็นต้น จากนั้นคุณสามารถเพิ่มผู้สังเกตการณ์ได้โดยเรียกใช้เมธอด addObserver() ของคลาส Lifecycle และส่งอินสแตนซ์ของผู้สังเกตการณ์ ดังที่แสดงในตัวอย่างต่อไปนี้
Kotlin
class MyObserver : DefaultLifecycleObserver {
override fun onResume(owner: LifecycleOwner) {
connect()
}
override fun onPause(owner: LifecycleOwner) {
disconnect()
}
}
myLifecycleOwner.getLifecycle().addObserver(MyObserver())
Java
public class MyObserver implements DefaultLifecycleObserver {
@Override
public void onResume(LifecycleOwner owner) {
connect()
}
@Override
public void onPause(LifecycleOwner owner) {
disconnect()
}
}
myLifecycleOwner.getLifecycle().addObserver(new MyObserver());
ในตัวอย่างข้างต้น ออบเจ็กต์ myLifecycleOwner จะใช้อินเทอร์เฟซ LifecycleOwner ซึ่งอธิบายไว้ในส่วนต่อไปนี้
LifecycleOwner
LifecycleOwner เป็นอินเทอร์เฟซเมธอดเดียวที่ระบุว่าคลาสมี Lifecycle โดยมีเมธอด 1 รายการคือ getLifecycle ซึ่งคลาสต้องนำไปใช้ หากคุณต้องการจัดการวงจรของกระบวนการสมัครทั้งหมดแทน โปรดดู ProcessLifecycleOwner
อินเทอร์เฟซนี้จะแยกการเป็นเจ้าของ Lifecycle ออกจากคลาสแต่ละคลาส เช่น Fragment และ AppCompatActivity และอนุญาตให้เขียนคอมโพเนนต์ที่ทำงานร่วมกับคลาสเหล่านั้นได้ คลาสแอปพลิเคชันที่กำหนดเองสามารถใช้อินเทอร์เฟซ LifecycleOwner ได้
คอมโพเนนต์ที่ใช้ DefaultLifecycleObserver จะทำงานร่วมกับคอมโพเนนต์ที่ใช้ LifecycleOwner ได้อย่างราบรื่น เนื่องจากเจ้าของสามารถระบุวงจรที่ผู้สังเกตการณ์ลงทะเบียนเพื่อดูได้
สำหรับตัวอย่างการติดตามตำแหน่ง เราสามารถทำให้คลาส MyLocationListener ใช้ DefaultLifecycleObserver แล้วเริ่มต้นด้วย Lifecycle ของกิจกรรมในเมธอด onCreate() ซึ่งจะช่วยให้คลาส MyLocationListener ทำงานได้ด้วยตนเอง หมายความว่าตรรกะในการตอบสนองต่อการเปลี่ยนแปลงสถานะวงจรจะได้รับการประกาศใน MyLocationListener แทนกิจกรรม การจัดเก็บตรรกะของคอมโพเนนต์แต่ละรายการจะช่วยให้จัดการตรรกะของกิจกรรมและ Fragment ได้ง่ายขึ้น
Kotlin
class MyActivity : AppCompatActivity() {
private lateinit var myLocationListener: MyLocationListener
override fun onCreate(...) {
myLocationListener = MyLocationListener(this, lifecycle) { location ->
// update UI
}
Util.checkUserStatus { result ->
if (result) {
myLocationListener.enable()
}
}
}
}
Java
class MyActivity extends AppCompatActivity {
private MyLocationListener myLocationListener;
public void onCreate(...) {
myLocationListener = new MyLocationListener(this, getLifecycle(), location -> {
// update UI
});
Util.checkUserStatus(result -> {
if (result) {
myLocationListener.enable();
}
});
}
}
Use Case ทั่วไปคือการหลีกเลี่ยงการเรียกใช้ Callback บางรายการหาก Lifecycle ไม่อยู่ในสถานะที่ดีในขณะนี้ ตัวอย่างเช่น หาก Callback เรียกใช้ธุรกรรม Fragment หลังจากบันทึกสถานะกิจกรรมแล้ว ก็จะทำให้เกิดข้อขัดข้อง ดังนั้นเราจึงไม่ต้องการเรียกใช้ Callback นั้น
เพื่อให้กรณีการใช้งานนี้เป็นเรื่องง่าย คลาส Lifecycle จะอนุญาตให้ออบเจ็กต์อื่นๆ ค้นหาสถานะปัจจุบันได้
Kotlin
internal class MyLocationListener(
private val context: Context,
private val lifecycle: Lifecycle,
private val callback: (Location) -> Unit
): DefaultLifecycleObserver {
private var enabled = false
override fun onStart(owner: LifecycleOwner) {
if (enabled) {
// connect
}
}
fun enable() {
enabled = true
if (lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED)) {
// connect if not connected
}
}
override fun onStop(owner: LifecycleOwner) {
// disconnect if connected
}
}
Java
class MyLocationListener implements DefaultLifecycleObserver {
private boolean enabled = false;
public MyLocationListener(Context context, Lifecycle lifecycle, Callback callback) {
...
}
@Override
public void onStart(LifecycleOwner owner) {
if (enabled) {
// connect
}
}
public void enable() {
enabled = true;
if (lifecycle.getCurrentState().isAtLeast(STARTED)) {
// connect if not connected
}
}
@Override
public void onStop(LifecycleOwner owner) {
// disconnect if connected
}
}
การติดตั้งใช้งานนี้ทำให้คลาส LocationListener ของเราตระหนักถึงวงจรอย่างสมบูรณ์ หากเราต้องใช้ LocationListener จากกิจกรรมหรือ Fragment อื่น เราก็แค่ต้องเริ่มต้นใช้งาน การดำเนินการตั้งค่าและการแยกส่วนทั้งหมดจะจัดการโดยคลาสเอง
หากไลบรารีมีคลาสที่ต้องทำงานร่วมกับวงจรของ Android เราขอแนะนำให้คุณใช้คอมโพเนนต์ที่รับรู้วงจร ไคลเอ็นต์ไลบรารีของคุณจะผสานรวมคอมโพเนนต์เหล่านั้นได้อย่างง่ายดายโดยไม่ต้องจัดการวงจรด้วยตนเองในฝั่งไคลเอ็นต์
การติดตั้งใช้งาน LifecycleOwner ที่กำหนดเอง
Fragment และ Activity ใน Support Library 26.1.0 ขึ้นไปใช้อินเทอร์เฟซ LifecycleOwner อยู่แล้ว
หากมีคลาสที่กำหนดเองซึ่งต้องการทำให้เป็น LifecycleOwner
คุณสามารถใช้คลาส LifecycleRegistry ได้ แต่ต้องส่งต่อเหตุการณ์
ไปยังคลาสนั้น ดังที่แสดงในตัวอย่างโค้ดต่อไปนี้
Kotlin
class MyActivity : Activity(), LifecycleOwner {
private lateinit var lifecycleRegistry: LifecycleRegistry
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
lifecycleRegistry = LifecycleRegistry(this)
lifecycleRegistry.markState(Lifecycle.State.CREATED)
}
public override fun onStart() {
super.onStart()
lifecycleRegistry.markState(Lifecycle.State.STARTED)
}
override fun getLifecycle(): Lifecycle {
return lifecycleRegistry
}
}
Java
public class MyActivity extends Activity implements LifecycleOwner {
private LifecycleRegistry lifecycleRegistry;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
lifecycleRegistry = new LifecycleRegistry(this);
lifecycleRegistry.markState(Lifecycle.State.CREATED);
}
@Override
public void onStart() {
super.onStart();
lifecycleRegistry.markState(Lifecycle.State.STARTED);
}
@NonNull
@Override
public Lifecycle getLifecycle() {
return lifecycleRegistry;
}
}
แนวทางปฏิบัติแนะนำสำหรับคอมโพเนนต์ที่รับรู้วงจร
- ทำให้ UI Controller (กิจกรรมและ Fragment) มีขนาดเล็กที่สุดเท่าที่จะเป็นไปได้
โดยไม่ควรพยายามรับข้อมูลของตนเอง แต่ให้ใช้
ViewModelเพื่อดำเนินการดังกล่าว และสังเกตออบเจ็กต์LiveDataเพื่อแสดงการเปลี่ยนแปลงกลับไปยังมุมมอง - ลองเขียน UI ที่ขับเคลื่อนด้วยข้อมูลซึ่งหน้าที่ของ UI Controller คือการอัปเดตมุมมองเมื่อข้อมูลมีการเปลี่ยนแปลง หรือแจ้งเตือนการดำเนินการของผู้ใช้กลับไปยัง
ViewModel - ใส่ตรรกะข้อมูลในคลาส
ViewModelViewModelควรทำหน้าที่เป็นตัวเชื่อมต่อระหว่างตัวควบคุม UI กับส่วนที่เหลือของแอป แต่โปรดทราบว่าการดึงข้อมูล (เช่น จากเครือข่าย) ไม่ใช่หน้าที่ของViewModelแต่ViewModelควรเรียกคอมโพเนนต์ที่เหมาะสมเพื่อดึงข้อมูล แล้วส่งผลลัพธ์กลับไปยังตัวควบคุม UI - ใช้การเชื่อมโยงข้อมูลเพื่อรักษาอินเทอร์เฟซที่สะอาดตาระหว่างมุมมองและตัวควบคุม UI ซึ่งจะช่วยให้คุณสร้างมุมมองที่ชัดเจนมากขึ้นและลดโค้ดอัปเดตที่ต้องเขียนในกิจกรรมและ Fragment หากต้องการดำเนินการนี้ในภาษาโปรแกรม Java ให้ใช้ไลบรารีอย่าง Butter Knife เพื่อหลีกเลี่ยงโค้ด Boilerplate และมีการแยกข้อมูลที่ดีขึ้น
- หาก UI ของคุณซับซ้อน ให้พิจารณาสร้างคลาส presenter เพื่อจัดการการแก้ไข UI ซึ่งอาจเป็นงานที่ต้องใช้ความพยายาม แต่จะช่วยให้ทดสอบคอมโพเนนต์ UI ได้ง่ายขึ้น
- หลีกเลี่ยงการอ้างอิงบริบท
ViewหรือActivityในViewModelหากViewModelมีอายุการใช้งานนานกว่ากิจกรรม (ในกรณีที่มีการเปลี่ยนแปลงการกำหนดค่า) กิจกรรมจะรั่วไหลและไม่ได้รับการกำจัดอย่างเหมาะสมโดย Garbage Collector - ใช้ Kotlin Coroutine เพื่อจัดการงานที่ใช้เวลานานและการดำเนินการอื่นๆ ที่ทำงานแบบอะซิงโครนัสได้
กรณีการใช้งานสำหรับคอมโพเนนต์ที่รับรู้ถึงวงจรชีวิต
คอมโพเนนต์ที่รับรู้ถึงวงจรจะช่วยให้คุณจัดการวงจรในกรณีต่างๆ ได้ง่ายขึ้นมาก ตัวอย่างเช่น
- การสลับระหว่างการอัปเดตตำแหน่งแบบคร่าวๆ และแบบละเอียด ใช้คอมโพเนนต์ที่รับรู้ถึงวงจรเพื่อเปิดใช้การอัปเดตตำแหน่งแบบละเอียดขณะที่แอปตำแหน่งของคุณปรากฏอยู่ และเปลี่ยนไปใช้การอัปเดตแบบคร่าวๆ เมื่อแอปทำงานอยู่เบื้องหลัง
LiveDataซึ่งเป็นคอมโพเนนต์ที่รับรู้ถึงวงจรชีวิตช่วยให้แอปอัปเดต UI โดยอัตโนมัติเมื่อผู้ใช้เปลี่ยนตำแหน่ง - การหยุดและเริ่มบัฟเฟอร์วิดีโอ ใช้คอมโพเนนต์ที่รับรู้ถึงวงจรเพื่อเริ่มการบัฟเฟอร์วิดีโอโดยเร็วที่สุด แต่เลื่อนการเล่นออกไปจนกว่าแอปจะเริ่มทำงานอย่างสมบูรณ์ นอกจากนี้ คุณยังใช้คอมโพเนนต์ที่รับรู้ถึงวงจรเพื่อสิ้นสุดการบัฟเฟอร์เมื่อแอปถูกทำลายได้ด้วย
- การเริ่มและหยุดการเชื่อมต่อเครือข่าย ใช้คอมโพเนนต์ที่รับรู้ถึงวงจรเพื่อเปิดใช้ข้อมูลอัปเดตแบบเรียลไทม์ (สตรีมมิง) ของข้อมูลเครือข่ายขณะที่แอปทำงานอยู่เบื้องหน้า และหยุดชั่วคราวโดยอัตโนมัติเมื่อแอปทำงานอยู่เบื้องหลัง
- การหยุดชั่วคราวและเล่นต่อสำหรับทรัพยากรที่ถอนออกได้แบบเคลื่อนไหว ใช้คอมโพเนนต์ที่รับรู้ถึงวงจรเพื่อจัดการการหยุดภาพเคลื่อนไหวที่วาดได้ชั่วคราวเมื่อแอปทำงานอยู่เบื้องหลัง และกลับมาแสดงภาพที่วาดได้อีกครั้งหลังจากแอปทำงานอยู่เบื้องหน้า
การจัดการเหตุการณ์การหยุด
เมื่อ Lifecycle เป็นของ AppCompatActivity หรือ Fragment สถานะของ Lifecycle จะเปลี่ยนเป็น CREATED และระบบจะส่งเหตุการณ์ ON_STOP เมื่อมีการเรียกใช้ onSaveInstanceState() ของ AppCompatActivity หรือ Fragment
เมื่อบันทึกสถานะของ Fragment หรือ AppCompatActivity โดยใช้ onSaveInstanceState ระบบจะถือว่า UI ของสถานะดังกล่าวเปลี่ยนแปลงไม่ได้จนกว่าจะมีการเรียกใช้ ON_START การพยายามแก้ไข UI หลังจากบันทึกสถานะแล้วมีแนวโน้มที่จะทำให้สถานะการนำทางของแอปพลิเคชันไม่สอดคล้องกัน ซึ่งเป็นสาเหตุที่ FragmentManager แสดงข้อยกเว้นหากแอปเรียกใช้ FragmentTransaction หลังจากบันทึกสถานะแล้ว ดูรายละเอียดได้ที่ commit()
LiveData ป้องกันกรณีที่เกิดขึ้นไม่บ่อยนี้ได้ทันทีโดยงดเว้นการเรียกใช้ Observer หาก Lifecycle ที่เชื่อมโยงกับ Observer ไม่ได้อยู่ในสถานะ STARTED เป็นอย่างน้อย เบื้องหลัง ระบบจะเรียกใช้ isAtLeast() ก่อนตัดสินใจเรียกใช้ Observer
แต่ระบบจะเรียกใช้เมธอด onStop() ของ AppCompatActivity หลังจาก onSaveInstanceState ซึ่งทำให้เกิดช่องว่างที่ไม่อนุญาตให้เปลี่ยนแปลงสถานะ UI แต่ยังไม่ได้ย้าย Lifecycle ไปยังสถานะ CREATED
เพื่อป้องกันปัญหานี้ คลาส Lifecycle ในเวอร์ชัน beta2 และต่ำกว่าจะทำเครื่องหมายสถานะเป็น CREATED โดยไม่ส่งเหตุการณ์ เพื่อให้โค้ดที่ตรวจสอบสถานะปัจจุบันได้รับค่าจริง แม้ว่าระบบจะยังไม่ส่งเหตุการณ์จนกว่าจะมีการเรียกใช้ onStop()
แต่โซลูชันนี้มีปัญหาสำคัญ 2 ประการ ได้แก่
- ใน API ระดับ 23 และต่ำกว่า ระบบ Android จะบันทึกสถานะของกิจกรรมไว้แม้ว่ากิจกรรมนั้นจะถูกกิจกรรมอื่นบดบังบางส่วนก็ตาม กล่าวคือ ระบบ Android จะเรียกใช้
onSaveInstanceState()แต่ไม่จำเป็นต้องเรียกใช้onStopซึ่งจะสร้างช่วงเวลาที่อาจยาวนานซึ่งผู้สังเกตการณ์ยังคงคิดว่าวงจรทำงานอยู่ แม้ว่าจะแก้ไขสถานะ UI ไม่ได้ก็ตาม - คลาสใดก็ตามที่ต้องการแสดงลักษณะการทำงานที่คล้ายกับคลาส
LiveDataต้องใช้วิธีแก้ปัญหาชั่วคราวที่Lifecycleเวอร์ชันbeta 2และต่ำกว่ามีให้
แหล่งข้อมูลเพิ่มเติม
ดูข้อมูลเพิ่มเติมเกี่ยวกับการจัดการวงจรด้วยคอมโพเนนต์ที่รับรู้วงจรได้ที่แหล่งข้อมูลเพิ่มเติมต่อไปนี้