LifecycleOwner — khái niệm, giao diện Jetpack và đăng ký sự kiện

LifecycleOwner là gì?

LifecycleOwner — là một giao diện từ gói androidx.lifecycle chứa một phương thức duy nhất getLifecycle() trả về một đối tượng Lifecycle. Đối tượng này theo dõi trạng thái hiện tại của thành phần (CREATED, STARTED, RESUMED, DESTROYED) và thông báo cho tất cả người quan sát đã đăng ký khi nó thay đổi. LifecycleOwner là một phần của Architecture Components và được bao gồm trong thư viện lifecycle-runtime.

Nhiệm vụ chính của giao diện là tiêu chuẩn hóa quyền truy cập vào vòng đời. Trước Jetpack, các nhà phát triển sử dụng đăng ký thủ công trong onStart và hủy đăng ký trong onStop, dẫn đến trùng lặp mã và lỗi. LifecycleOwner giải quyết vấn đề này bằng cách cung cấp một cơ chế thống nhất cho tất cả các thành phần Android. Thay vì gọi tường minh các phương thức vòng đời, nhà phát triển đăng ký vào Lifecycle một lần và các thông báo đến tự động.

Giao diện được khai báo trong Kotlin như một giao diện chức năng với một phương thức trừu tượng duy nhất:

interface LifecycleOwner {
    val lifecycle: Lifecycle
}

Nhờ tính chất chức năng của giao diện, nó dễ dàng được triển khai bằng cách sử dụng delegate hoặc lambda. Điều này đặc biệt thuận tiện cho việc tạo Custom Views và các lớp ViewModel cần phản ứng với các thay đổi vòng đời của host. Đối tượng Lifecycle nhận được từ getLifecycle() cung cấp các phương thức addObserver và removeObserver để quản lý đăng ký.

Cách LifecycleOwner hoạt động

LifecycleOwner hoạt động cùng với hai lớp chính: Lifecycle và LifecycleObserver. Lifecycle lưu trữ trạng thái hiện tại của thành phần dưới dạng enum State (INITIALIZED, CREATED, STARTED, RESUMED, DESTROYED) và theo dõi các chuyển đổi giữa chúng. Khi trạng thái thay đổi, Lifecycle thông báo cho tất cả người quan sát đã đăng ký, gọi các phương thức được chú thích tương ứng. Cơ chế này được gọi là "lifecycle-aware" — mã chỉ được thực thi khi thành phần ở trạng thái phù hợp.

Cơ chế truyền sự kiện dựa trên mẫu Observer. LifecycleOwner đóng vai trò là Observable, và triển khai LifecycleObserver đóng vai trò là Observer. Activity hoặc Fragment khi thay đổi trạng thái (onCreate → onStart → onResume → onPause → onStop → onDestroy) thông báo cho Lifecycle thông qua cơ chế nội bộ ReportFragment, được thêm vào hệ thống AndroidX tự động. Nhà phát triển không cần gọi thủ công các phương thức của Lifecycle — mọi thứ diễn ra tự động.

Một chi tiết quan trọng: Lifecycle đảm bảo rằng các sự kiện ON_STOP và ON_DESTROY sẽ được gửi ngay cả trong trường hợp quá trình bị crash. Điều này làm cho LifecycleOwner trở thành công cụ đáng tin cậy để giải phóng tài nguyên quan trọng. Để lưu trạng thái thông thường, nên sử dụng SavedStateHandle trong ViewModel, nhưng LifecycleOwner cung cấp mức bảo mật cơ bản.

LifecycleObserver và DefaultLifecycleObserver

Có hai cách để đăng ký sự kiện của LifecycleOwner: LifecycleObserver cổ điển với chú thích và DefaultLifecycleObserver hiện đại với các phương thức tường minh. Cách tiếp cận thứ hai được Google khuyến nghị từ năm 2022 vì nó cung cấp an toàn kiểu tốt hơn và tránh phản xạ (reflection) vốn được sử dụng trong cách tiếp cận chú thích. DefaultLifecycleObserver yêu cầu Java 8+ hoặc Kotlin và được ưu tiên cho các dự án mới.

Ví dụ đăng ký thông qua DefaultLifecycleObserver:

class MyObserver : DefaultLifecycleObserver {
    override fun onStart(owner: LifecycleOwner) {
        // Chỉ bắt đầu theo dõi GPS khi thành phần hoạt động
        startLocationUpdates()
    }

    override fun onStop(owner: LifecycleOwner) {
        // Dừng an toàn khi chuyển sang chế độ nền
        stopLocationUpdates()
    }
}

// Kết nối:
lifecycleOwner.lifecycle.addObserver(MyObserver())

Mỗi phương thức của DefaultLifecycleObserver nhận LifecycleOwner làm tham số. Điều này cho phép người quan sát truy cập vào ngữ cảnh của thành phần đang thực thi mà không cần truyền nó riêng biệt. Cách tiếp cận này làm cho mã trở nên mô-đun hơn và dễ kiểm thử hơn — Observer không phụ thuộc vào triển khai cụ thể của Activity hoặc Fragment mà làm việc với abstraction LifecycleOwner.

Cách tiếp cận chú thích LifecycleObserver

Cách cũ sử dụng chú thích @OnLifecycleEvent vẫn còn được tìm thấy trong các dự án cũ, nhưng không được khuyến nghị cho mã mới. Phản xạ cần thiết để xử lý chú thích thêm chi phí và có thể dẫn đến lỗi không được phát hiện tại thời điểm biên dịch. Google chính thức khuyên nên di chuyển sang DefaultLifecycleObserver.

// Phương pháp cũ — không được khuyến nghị cho dự án mới
class MyLegacyObserver : LifecycleObserver {
    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun onStart() {
        startLocationUpdates()
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    fun onStop() {
        stopLocationUpdates()
    }
}

Cách tiếp cận chú thích có một nhược điểm đáng kể: thiếu kiểm soát thời gian sống của Observer. Nếu nhà phát triển quên hủy đăng ký Observer khi LifecycleOwner bị hủy, đối tượng Observer sẽ vẫn còn trong bộ nhớ cho đến khi trình thu gom rác được gọi. DefaultLifecycleObserver giải quyết vấn đề này — Observer được gắn với Lifecycle và tự động hủy đăng ký khi chuyển sang trạng thái DESTROYED.

LifecycleOwner trong Activity và Fragment

Từ AppCompat 1.1.0 và AndroidX Fragment 1.2.0, tất cả Activity và Fragment kế thừa AppCompatActivity hoặc Fragment tự động trở thành LifecycleOwner. Điều này có nghĩa là phương thức getLifecycle() có sẵn theo mặc định và việc đăng ký sự kiện vòng đời hoạt động mà không cần cấu hình thêm. Nhà phát triển chỉ cần gọi lifecycle.addObserver() từ bất kỳ đâu trong Activity hoặc Fragment.

Hãy xem xét ví dụ tích hợp LifecycleOwner trong Activity:

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        lifecycle.addObserver(LocationObserver(this))
    }
}

Trong ví dụ này, lifecycle là một extension property có sẵn nhờ AndroidX Activity. Observer LocationObserver sẽ tự động nhận thông báo về việc bắt đầu (ON_START) và dừng (ON_STOP) của Activity. Khi xoay màn hình, Observer được thông báo về ON_DESTROY và sau đó ON_CREATE, cho phép xử lý chính xác các thay đổi cấu hình mà không cần mã bổ sung.

LifecycleOwner trong Fragment

Fragment triển khai LifecycleOwner thông qua giao diện và Lifecycle của nó được gắn với vòng đời của Fragment, không phải Activity cha. Điều này rất quan trọng: Lifecycle của Fragment chuyển sang DESTROYED khi Fragment bị xóa khỏi giao dịch, trong khi Activity có thể vẫn ở trạng thái RESUMED. Sự khác biệt này cho phép Observer đăng ký riêng biệt vào vòng đời của mỗi thành phần.

class MyFragment : Fragment() {
    private val uiStateObserver = UiStateObserver()

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        lifecycle.addObserver(uiStateObserver)
    }
}

Một lợi thế quan trọng của việc sử dụng LifecycleOwner trong Fragment là hủy đăng ký tự động khi Fragment chuyển sang DESTROYED. Điều này đặc biệt quan trọng đối với ViewPager, nơi các Fragment có thể được tạo và hủy động. Việc quản lý đăng ký thủ công trong kịch bản này sẽ cực kỳ phức tạp và dễ xảy ra lỗi.

Tạo LifecycleOwner tùy chỉnh

Giao diện LifecycleOwner có thể được triển khai trong bất kỳ lớp nào có vòng đời. Điều này hữu ích cho Custom Views, Services và thậm chí ViewModel trong một số giải pháp kiến trúc. Google cung cấp lớp trợ giúp LifecycleRegistry quản lý trạng thái của Lifecycle và tạo sự kiện. Nhà phát triển cần gọi thủ công các phương thức tương ứng của LifecycleRegistry khi trạng thái thành phần thay đổi.

Ví dụ triển khai LifecycleOwner trong Custom View:

class MyCustomView(
    context: Context,
    attrs: AttributeSet?
) : FrameLayout(context, attrs), LifecycleOwner {

    private val lifecycleRegistry = LifecycleRegistry(this)

    override val lifecycle: Lifecycle
        get() = lifecycleRegistry

    fun onStart() {
        lifecycleRegistry.setCurrentState(Lifecycle.State.STARTED)
    }

    fun onStop() {
        lifecycleRegistry.setCurrentState(Lifecycle.State.CREATED)
    }
}

Trong ví dụ này, LifecycleRegistry đóng vai trò là kho lưu trữ trạng thái. Các phương thức onStart/onStop nên được gọi bởi thành phần cha (ví dụ Activity) khi Custom View trở nên hiển thị hoặc bị ẩn. LifecycleRegistry tự động tính toán các sự kiện cần thiết cho việc chuyển đổi giữa các trạng thái và thông báo cho tất cả Observer đã đăng ký.

Khi triển khai LifecycleOwner tùy chỉnh, điều quan trọng là tuân thủ quy tắc: trạng thái của LifecycleRegistry phải được cập nhật cuối cùng trong phương thức vòng đời tương ứng, sau tất cả các thao tác khác. Điều này đảm bảo rằng Observer nhận được thông báo khi thành phần đã hoàn toàn sẵn sàng cho trạng thái mới. Sử dụng LifecycleRegistry.createUnsafe như một giải pháp thay thế cũng có thể, nhưng cần thận trọng với luồng.

LifecycleOwner trong các thành phần Jetpack

LifecycleOwner là nền tảng cho một số thành phần chính của Android Jetpack. LiveData sử dụng LifecycleOwner để xác định trạng thái hoạt động và tự động hủy đăng ký khi thành phần bị hủy. ViewModel không triển khai trực tiếp LifecycleOwner nhưng có thể nhận Lifecycle thông qua SavedStateHandle. Navigation Component sử dụng LifecycleOwner để quản lý đăng ký trong NavBackStackEntry. Hiểu được mối quan hệ này giúp xây dựng kiến trúc ứng dụng trên nền tảng vững chắc.

Tương tác của LiveData với LifecycleOwner:

class ExampleActivity : AppCompatActivity() {
    private val viewModel: ExampleViewModel by viewModels()

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

        viewModel.userData.observe(this) { data ->
            // this — LifecycleOwner (Activity)
            // Mã chỉ được thực thi khi Activity ở trạng thái RESUMED
            updateUI(data)
        }
    }
}

LiveData yêu cầu LifecycleOwner trong phương thức observe() vì điều này đảm bảo rằng các cập nhật giao diện chỉ xảy ra ở trạng thái hoạt động. Nếu Activity ở chế độ nền, LiveData giữ giá trị cuối cùng nhưng không thông báo cho Observer. Khi quay lại RESUMED, Observer nhận được giá trị hiện tại mà không cần yêu cầu mạng hoặc cơ sở dữ liệu bổ sung.

DataBinding cũng sử dụng LifecycleOwner để gắn các trường observable vào vòng đời của Activity hoặc Fragment. Điều này cho phép tránh rò rỉ bộ nhớ trong sự kết hợp ViewModel + DataBinding — tất cả đăng ký tự động được dọn dẹp khi LifecycleOwner bị hủy. Cách tiếp cận này làm cho mã trở nên khai báo và an toàn.

Khuyến nghị sử dụng

Việc sử dụng đúng LifecycleOwner yêu cầu tuân thủ một số quy tắc chính. Đầu tiên và quan trọng nhất: luôn đăng ký Observer trong onCreate/onViewCreated, không phải sau đó. Điều này đảm bảo Observer nhận được trạng thái ban đầu của Lifecycle (CREATED sau onCreate) và không bỏ lỡ sự kiện. Quy tắc thứ hai: sử dụng DefaultLifecycleObserver thay vì cách tiếp cận chú thích cho tất cả các dự án mới.

• Không lưu trữ tham chiếu đến LifecycleOwner trong các trường tĩnh hoặc singleton — điều này gây rò rỉ toàn bộ Activity
• Kiểm tra trạng thái Lifecycle thông qua getCurrentState() trước khi thực hiện các thao tác nhạy cảm với trạng thái
• Không tạo Observer bên trong lambda — mỗi lần tái tạo sẽ tạo một đối tượng mới và Observer cũ sẽ không tự động hủy đăng ký
• Sử dụng repeatOnLifecycle cho coroutine — khối được bắt đầu khi vào trạng thái chỉ định và bị hủy khi thoát khỏi nó
• Không gọi setCurrentState trong LifecycleRegistry từ luồng nền — điều này vi phạm đảm bảo đơn luồng của vòng đời

Cách tiếp cận hiện đại để làm việc với coroutine và LifecycleOwner — extension repeatOnLifecycle:

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

Mẫu này đảm bảo rằng collect trên Flow chỉ hoạt động ở trạng thái STARTED hoặc RESUMED. Khi chuyển sang STOPPED, việc thu thập tự động bị hủy và khi quay lại STARTED, nó được khởi động lại. repeatOnLifecycle thay thế việc hủy đăng ký thủ công khỏi Flow trong Fragment và là cách tiếp cận được Google khuyến nghị để làm việc với các luồng dữ liệu bất đồng bộ trong các thành phần giao diện.

Một khuyến nghị quan trọng khác: không lạm dụng LifecycleObserver cho logic không liên quan đến vòng đời. Nếu một thành phần cần thực hiện hành động ở trạng thái cụ thể nhưng không yêu cầu hủy đăng ký khi bị hủy, tốt hơn nên sử dụng các lời gọi phương thức tường minh trong onStart/onStop. LifecycleObserver phù hợp cho các thành phần tồn tại lâu dài (LocationListener, SensorManager) nơi việc quản lý đăng ký thủ công phức tạp và dễ xảy ra lỗi.