AndroidJetPack中Lifecycle原理和机制

Lifecycle原理和机制

Lifectcle的用来感知页面的生命周期，并通过利用观察者模式，将感知到的生命周期告知到相应的回调中去。

ComponentActivity中的实现探讨

在ComponentActivity首先实现了LifecycleOwner接口并返回LifecycleRegistry对象

public class ComponentActivity extends androidx.core.app.ComponentActivity implements
        ContextAware,
        LifecycleOwner,
        ViewModelStoreOwner,
        HasDefaultViewModelProviderFactory,
        SavedStateRegistryOwner,
        OnBackPressedDispatcherOwner,
        ActivityResultRegistryOwner,
        ActivityResultCaller {
   

    private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
    
    public Lifecycle getLifecycle() {
   
        return mLifecycleRegistry;
    }        
 }

生命周期的感知与传递

为什么说ComponentActivity已经实现好生命周期观察派发，其实在它执行onCreate的生命周期时，其内部会添加一个ReportFragment，接下来请查看部分源码：

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
   
        mSavedStateRegistryController.performRestore(savedInstanceState);
        
        mContextAwareHelper.dispatchOnContextAvailable(this);
        super.onCreate(savedInstanceState);
        //在这里调用 ReportFragment.injectIfNeededIn 静态方法 动态添加一个ReportFragment
        ReportFragment.injectIfNeededIn(this);
        if (mContentLayoutId != 0) {
   
            setContentView(mContentLayoutId);
        }
    }
    
    public static void injectIfNeededIn(Activity activity) {
   
        if (Build.VERSION.SDK_INT >= 29) {
   
            // On API 29+, we can register for the correct Lifecycle callbacks directly
            LifecycleCallbacks.registerIn(activity);
        }
        // Prior to API 29 and to maintain compatibility with older versions of
        // ProcessLifecycleOwner (which may not be updated when lifecycle-runtime is updated and
        // need to support activities that don't extend from FragmentActivity from support lib),
        // use a framework fragment to get the correct timing of Lifecycle events
        android.app.FragmentManager manager = activity.getFragmentManager();
        if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
   
            manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
            // Hopefully, we are the first to make a transaction.
            manager.executePendingTransactions();
        }
    }

其实在ReportFragment最为核心的在于两个地方：静态内部类LifecycleCallbacks、静态方法dispatch,

其中LifecycleCallbacks中在高于29以上版本中它通过实现了ActivityLifecycleCallbacks这个接口，通过回调及时的调用dispatch方法将相应的Activity中的生命周期及时的派发出去

    @RequiresApi(29)
    static class LifecycleCallbacks implements Application.ActivityLifecycleCallbacks {
   

        static void registerIn(Activity activity) {
   
            activity.registerActivityLifecycleCallbacks(new LifecycleCallbacks());
        }

        @Override
        public void onActivityPostCreated(@NonNull Activity activity,
                @Nullable Bundle savedInstanceState) {
   
            dispatch(activity, Lifecycle.Event.ON_CREATE);
        }

        @Override
        public void onActivityPostStarted(@NonNull Activity activity) {
   
            dispatch(activity, Lifecycle.Event.ON_START);
        }


        @Override
        public void onActivityPostResumed(@NonNull Activity activity) {
   
            dispatch(activity, Lifecycle.Event.ON_RESUME);
        }

        @Override
        public void onActivityPrePaused(@NonNull Activity activity) {
   
            dispatch(activity, Lifecycle.Event.ON_PAUSE);
        }


        @Override
        public void onActivityPreStopped(@NonNull Activity activity) {
   
            dispatch(activity, Lifecycle.Event.ON_STOP);
        }


        @Override
        public void onActivityPreDestroyed(@NonNull Activity activity) {
   
            dispatch(activity, Lifecycle.Event.ON_DESTROY);
        }
    }

那么我们来看看ReportFragment中的dispatch是如何实现事件的派发

    static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {
   
        if (activity instanceof LifecycleRegistryOwner) {
   
            ((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
            return;
        }

        if (activity instanceof LifecycleOwner) {
   
            Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
            if (lifecycle instanceof LifecycleRegistry) {
   
                ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
            }
        }
    }

    public void handleLifecycleEvent(@NonNull Lifecycle.Event event