序言

2024-01-01 18:14:21

Android 应用生命周期：深入解析

了解应用程序的生命周期对于优化应用程序性能和用户体验至关重要。 Android 应用的生命周期贯穿于应用从启动到销毁的整个过程，涵盖了各种组件，如 Activity、Fragment、Service 和 Application。本文将深入剖析 Android 应用生命周期的运作原理，并通过源码解析来提供对实现细节的深入理解。

组件的生命周期

每个 Android 组件都有自己的生命周期，由一系列按顺序触发的回调方法组成。这些生命周期对于管理组件的状态和行为至关重要。

Activity 生命周期

Activity 生命周期负责管理 Activity 的可见性和交互性：

onCreate()： Activity 第一次创建时调用。
onStart()： Activity 变得可见时调用。
onResume()： Activity 获得焦点时调用。
onPause()： Activity 失去焦点时调用。
onStop()： Activity 变得不可见时调用。
onDestroy()： Activity 被销毁时调用。

Fragment 生命周期

Fragment 生命周期与 Activity 生命周期类似，但仅影响 Fragment 本身：

onAttach()： Fragment 第一次附加到 Activity 时调用。
onCreate()： Fragment 第一次创建时调用。
onStart()： Fragment 变得可见时调用。
onResume()： Fragment 获得焦点时调用。
onPause()： Fragment 失去焦点时调用。
onStop()： Fragment 变得不可见时调用。
onDestroy()： Fragment 被销毁时调用。
onDetach()： Fragment 从 Activity 中分离时调用。

Service 生命周期

Service 生命周期不同于 Activity 或 Fragment，因为它专注于后台任务：

onCreate()： Service 第一次创建时调用。
onStartCommand()： 每次 Service 启动时调用。
onDestroy()： Service 被销毁时调用。

Application 生命周期

Application 生命周期管理整个应用程序的生命周期，并且比组件的生命周期更广泛：

onCreate()： Application 第一次创建时调用。
onTerminate()： Application 被销毁时调用。

生命周期管理

Android 使用 LifecycleRegistry 类来管理组件的生命周期状态。LifecycleRegistry 维护一个观察者列表，这些观察者对组件生命周期事件感兴趣。

LifecycleObserver 接口允许组件实现生命周期感知功能。组件可以实现此接口并使用 @OnLifecycleEvent 注解标记生命周期事件处理程序方法。

LifecycleEventObserver 类是 LifecycleObserver 的具体实现，它将生命周期事件通知给观察者。

优化生命周期管理

通过优化生命周期管理，您可以提高应用程序的性能和响应能力。以下是一些提示：

正确使用生命周期方法： 根据组件的预期行为和交互性，选择合适的生命周期方法。
使用 LifecycleObserver： 实现 LifecycleObserver 接口简化了生命周期事件处理。
避免生命周期泄漏： 确保在组件不再需要时注销生命周期观察者。
使用 LifecycleAware 组件： 使用支持 Lifecycle 的组件，如 LiveData，可以自动化生命周期管理。

源码解析

LifecycleRegistry

public class LifecycleRegistry extends Lifecycle {

    private Map<LifecycleObserver, ObserverWithState> mObserverMap = new HashMap<>();

    @Override
    public void addObserver(@NonNull LifecycleObserver observer) {
        ObserverWithState observerWithState = new ObserverWithState(observer, mState);
        mObserverMap.put(observer, observerWithState);
        dispatch(observerWithState);
    }

    private void dispatch(ObserverWithState observerWithState) {
        LifecycleObserver observer = observerWithState.getObserver();
        switch (observerWithState.mState) {
            case DESTROYED:
                observer.onDestroy(this);
                break;
            case INITIALIZED:
                observer.onCreate(this);
                break;
            case STARTED:
                observer.onStart(this);
                break;
            case RESUMED:
                observer.onResume(this);
                break;
            case PAUSED:
                observer.onPause(this);
                break;
            case STOPPED:
                observer.onStop(this);
                break;
        }
    }

    @Override
    public void removeObserver(@NonNull LifecycleObserver observer) {
        mObserverMap.remove(observer);
    }
}

LifecycleObserver

public interface LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    void onCreate(@NonNull LifecycleOwner owner);

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    void onStart(@NonNull LifecycleOwner owner);

    ...

}

LifecycleEventObserver

public class LifecycleEventObserver extends LifecycleObserver {

    private final LifecycleOwner mOwner;

    public LifecycleEventObserver(LifecycleOwner owner) {
        mOwner = owner;
    }

    @Override
    public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event) {
        if (mOwner == source) {
            dispatch(event);
        }
    }

    private void dispatch(Lifecycle.Event event) {
        switch (event) {
            case ON_CREATE:
                onCreate(mOwner);
                break;
            case ON_START:
                onStart(mOwner);
                break;
            ...
        }
    }
}

LifecycleObserverAdapter

public class LifecycleObserverAdapter extends LifecycleEventObserver {

    private final LifecycleObserver mObserver;

    public LifecycleObserverAdapter(LifecycleOwner owner, LifecycleObserver observer) {
        super(owner);
        mObserver = observer;
    }

    @Override
    public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event) {
        if (mOwner == source) {
            mObserver.onStateChanged(source, event);
        }
    }
}