实现Activity/Fragment生命周期回调的几种方式

Activity/Fragment的生命周期每个Android的开发人员几乎每一天都要打交道，其重要性不言而喻。那么你知道几种监听回调的方法呢：直接重写Activity/Fragment生命周期方法？经过Application#registerActivityLifecycleCallbacks()/FragmentManager#registerFragmentLifecycleCallbacks()注册回调?实现LifecycleObserver接口？继承BaseActivity/BaseFragment？方法多多，让咱们逐条一块儿展开看看吧！ #1.直接重写Activity/Fragment生命周期方法 这里展开就有些老生常谈了。但仍是有一点值得一提，那就是Android几乎每个生命周期回调都会要求调用父类方法，若是不调用将会报错，而检测是否调用的核心就是Activity.mCalled变量，经过对该变量的判断，即可知道是否调用了父类方法。固然针对编译器的检测，则是经过@CallSuper注解实现的。 ###优势：可以覆盖到全部暴露的生命周期方法。 ###缺点：仅能针对本身工程的Activity进行覆写，拥有必定的局限性。 #2.registerLifecycleCallbacks ##a.添加Activity回调 Application#registerActivityLifecycleCallbacks()这一API是在API Level 14后添加的。经过该方法，咱们能够传递一个ActivityLifecycleCallbacks的实例，该接口声明以下：

public interface ActivityLifecycleCallbacks {
        void onActivityCreated(Activity activity, Bundle savedInstanceState);
        void onActivityStarted(Activity activity);
        void onActivityResumed(Activity activity);
        void onActivityPaused(Activity activity);
        void onActivityStopped(Activity activity);
        void onActivitySaveInstanceState(Activity activity, Bundle outState);
        void onActivityDestroyed(Activity activity);
    }
复制代码

该方法是一个线程安全的方法，经过该方法添加的监听器，都存储在Application的mActivityLifecycleCallbacks这一ArrayList中。那么callbacks的对应方法又是在什么时候调用的呢？答案就在Activity中。以onActivityCreated()回调为例：

protected void onCreate(@Nullable Bundle savedInstanceState) {
        // ...省略一段代码
        mFragments.dispatchCreate();
        getApplication().dispatchActivityCreated(this, savedInstanceState);
        if (mVoiceInteractor != null) {
            mVoiceInteractor.attachActivity(this);
        }
        mRestoredFromBundle = savedInstanceState != null;
        mCalled = true;
    }
复制代码

关键就在这一行getApplication().dispatchActivityCreated(this, savedInstanceState);。经过查看源码咱们发现，Application中一一声明了与ActivityLifecycleCallbacks中方法对应的dispatchActivityXXX()方法，以Application#dispatchActivityCreated()为例：

void dispatchActivityCreated(Activity activity, Bundle savedInstanceState) {
        Object[] callbacks = collectActivityLifecycleCallbacks();
        if (callbacks != null) {
            for (int i=0; i<callbacks.length; i++) {
                ((ActivityLifecycleCallbacks)callbacks[i]).onActivityCreated(activity,
                        savedInstanceState);
            }
        }
    }
复制代码

Application会遍历这一时刻添加的全部ActivityLifecycleCallbacks并回调对应的生命周期方法。同时咱们也发现，这一方式没法作到在Activity的声明周期调用以前作一些事情，由于回调生在在supert.onXXX()中。 ##b.添加Fragment回调 FragmentManager#registerFragmentlifecyclecallbacks()这一API是在support library version 25.1.0中添加的。咱们能够经过传递一个``类的实现类以及一个boolean类型的变量来实现生命周期的监听，该抽象类声明以下：

public abstract static class FragmentLifecycleCallbacks {

        public void onFragmentPreAttached(@NonNull FragmentManager fm, @NonNull Fragment f, @NonNull Context context) {}

        public void onFragmentAttached(@NonNull FragmentManager fm, @NonNull Fragment f, @NonNull Context context) {}

        public void onFragmentPreCreated(@NonNull FragmentManager fm, @NonNull Fragment f, @Nullable Bundle savedInstanceState) {}

        public void onFragmentCreated(@NonNull FragmentManager fm, @NonNull Fragment f, @Nullable Bundle savedInstanceState) {}

        public void onFragmentActivityCreated(@NonNull FragmentManager fm, @NonNull Fragment f, @Nullable Bundle savedInstanceState) {}

        public void onFragmentViewCreated(@NonNull FragmentManager fm, @NonNull Fragment f, @NonNull View v, @Nullable Bundle savedInstanceState) {}

        public void onFragmentStarted(@NonNull FragmentManager fm, @NonNull Fragment f) {}

        public void onFragmentResumed(@NonNull FragmentManager fm, @NonNull Fragment f) {}

        public void onFragmentPaused(@NonNull FragmentManager fm, @NonNull Fragment f) {}

        public void onFragmentStopped(@NonNull FragmentManager fm, @NonNull Fragment f) {}

        public void onFragmentSaveInstanceState(@NonNull FragmentManager fm, @NonNull Fragment f, @NonNull Bundle outState) {}

        public void onFragmentViewDestroyed(@NonNull FragmentManager fm, @NonNull Fragment f) {}

        public void onFragmentDestroyed(@NonNull FragmentManager fm, @NonNull Fragment f) {}

        public void onFragmentDetached(@NonNull FragmentManager fm, @NonNull Fragment f) {}
    }
复制代码

值得注意的是，相比Application的方法相比，FragmentManager的方法多了一个参数：boolean recursive,若是该参数为true，则会为全部子孙Fragment也注册回调。 首先，Fragment的生命周期由FragmentManager经过moveToState()方法调用。一样，这里以onFragmentCreated为例，其调用流程以下： moveToState() -> dispatchOnFragmentCreated(),dispatchOnFragmentCreated()代码：

void dispatchOnFragmentCreated(@NonNull Fragment f, @Nullable Bundle savedInstanceState, boolean onlyRecursive) {
        // ...省略一段代码
        // 遍历callback回调声明周期方法
        for (FragmentLifecycleCallbacksHolder holder : mLifecycleCallbacks) {
            if (!onlyRecursive || holder.mRecursive) {
                holder.mCallback.onFragmentCreated(this, f, savedInstanceState);
            }
        }
    }
复制代码

到这里咱们能够发现，与ActivityLifecycleCallbacks同样，这一方式一样在onXXX()方法以后进行。 综上所属，这种方式的优缺点以下： ###优势：

• 能够统一监听全部Activity/Fragment，方便管理。
• 不侵入已有代码，耦合性较低。
• 并且能够操做第三方Activity/Fragment的声明周期。 ###缺点：仅能在相应周期回调后操做，是这一方法惟一的缺点。 #3.BaseActivity/BaseFragment 这一方法就是实现一个基类Activity/Fragment，在里面实现一些通用的方法，让项目中的activity都继承它，来达到封装的目的。可是该方法缺点也很明显，因为Java的继承机制只容许一个类拥有惟一父类，因此该方法没法用于第三方框架也使用该方式的场景，而且侵入性强。 #4.实现LifecycleObserver 该方法是支持库中的类，现已嵌入androidX包中。该接口声明以下：

public interface LifecycleObserver {}
复制代码

能够看到，这就是一个空接口，他的意义就是标记类,由于仅仅实现该方法并不能监控任何生命周期回调。为了监控生命周期，咱们还须要配合@OnLifecycleEvent注解一同食用：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface OnLifecycleEvent {
    Lifecycle.Event value();
}
复制代码

该注解接收一个Lifecycle.Event类型的参数，这是一个枚举类，声明了能够监控到的生命周期变动事件：

public enum Event {
        ON_CREATE,
        ON_START,
        ON_RESUME,
        ON_PAUSE,
        ON_STOP,
        ON_DESTROY,
        ON_ANY
    }
复制代码

其中值得说明的是ON_ANY，该值表示任何变动事件都将回调。完整的例子以下：

class LifecycleListener: LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
    fun onStateChanged(owner:LifecycleOwner,event:Lifecycle.Event){
        Log.e("LifecycleListener","owner $owner,event $event")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
    fun onStateChanged(owner:LifecycleOwner){
        Log.e("LifecycleListener","owner $owner")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
    fun onStateChanged(){
        Log.e("LifecycleListener","called")
    }

}
复制代码

须要注意两点：

• 实现LifecycleObserver的类，必须拥有一个无参的构造函数；
• @OnLifecycleEvent注解的方法，参数能够有0-2个，其中1-2的参数类型，必须按如上声明，不然会报错（由于系统只会按照上述顺序传参） 接下来还有最后一步：注册观察者！

class TestActivity : BaseActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // 添加Observer
        lifecycle.addObserver(LifecycleListener())
    }
}
复制代码

###ps：Fragment与Activity使用方式相同 这一步是经过调用Lifecycle#addObserver()实现的，对于ComponentActivity而言，实际调用的是LifecycleRegistry#addObserver()方法。 ##优势：

• 侵入性低
• 使用灵活 ##缺点：
• 可监控生命周期种类较少
• 没法对第三方Activity/Fragment直接使用 下面让咱们来分析一下，这一方式是如何实现的！ Lifecycle组件的实现原理