Glide源码分析3 -- 绑定Activity生命周期

1. 概述和核心类

Glide中一个重要特性是Request可以随Activity或Fragment的onStart而resume，onStop而pause，onDestroy而clear，从而节约流量和内存，并且防止内存泄露，这一切都由Glide在内部实现了。用户唯一要注意的是，Glide.with()方法中尽量传入Activity或Fragment，而不是Application，不然没办法进行生命周期管理。后面分绑定流程和生命周期调用流程来分析整个实现原理。实现这一切的核心类如下。

1）RequestManager，实现了LifeCycleListener，主要作用为结合Activity或Fragment生命周期，对Request进行管理，如pauseRequests(), resumeRequests(), clearRequests()

2） RequestManagerRetriever，获取RequestManager，和SupportRequestManagerFragment，并将二者绑定，从而在fragment的生命周期方法中可回调到RequestManager对request进行生命周期管理的相应方法。

3） SupportRequestManagerFragment, 空白Fragment，与RequestManager进行了绑定，作用为提供Fragment生命周期管理方法入口，如onStart(), onStop(), onDestroy()。

4）ActivityFragmentLifecycle, 管理LifecycleListener， 空白Fragment会回调它的onStart(), onStop(), onDestroy()

5）LifecycleListener，接口，定义生命周期管理方法，onStart(), onStop(), onDestroy(). RequestManager实现了它。

2.绑定流程

RequestManager和SupportRequestManagerFragment会进行绑定，流程图如下

1）我们由Glide.with(activity）或Glide.with(fragment)将当前Activity或Fragment传入，从而Glide可以将Request和他们进行生命周期绑定。以Activity为例

public class Glide {
    public static RequestManager with(Activity activity) {
        // 获取RequestManagerRetriever中的单例INSTANCE
        RequestManagerRetriever retriever = RequestManagerRetriever.get();
        // 由RequestManagerRetriever获取RequestManager
        return retriever.get(activity);
    }
 }

2）retriever.get(activity)

public class RequestManagerRetriever implements Handler.Callback {

    public RequestManager get(FragmentActivity activity) {
        if (Util.isOnBackgroundThread()) {
            return get(activity.getApplicationContext());
        } else {
            assertNotDestroyed(activity);
            // 获取FragmentManager
            FragmentManager fm = activity.getSupportFragmentManager();
            // 创建空白Fragment，和RequestManager，并将二者绑定
            return supportFragmentGet(activity, fm);
        }
    }

    // 获取SupportRequestManagerFragment，创建RequestManager
    RequestManager supportFragmentGet(Context context, FragmentManager fm) {
        // 获取SupportRequestManagerFragment， 它是一个空白的Fragment，主要作用是利用这个Fragment进行request生命周期管理
        SupportRequestManagerFragment current = getSupportRequestManagerFragment(fm);
        RequestManager requestManager = current.getRequestManager();
        if (requestManager == null) {
            // 创建RequestManager，并将SupportRequestManagerFragment中的LifeCycle传入，从而将Fragment和RequestManager这个LifeCycleListener绑定
            requestManager = new RequestManager(context, current.getLifecycle(), current.getRequestManagerTreeNode());
            current.setRequestManager(requestManager);
        }
        return requestManager;
    }

    // 创建SupportRequestManagerFragment
    SupportRequestManagerFragment getSupportRequestManagerFragment(final FragmentManager fm) {
        // 如果已经创建过，直接由tag可以找到。故可知，同一个Activity或父Fragment中只会创建一个SupportRequestManagerFragment
        SupportRequestManagerFragment current = (SupportRequestManagerFragment) fm.findFragmentByTag(


           FRAGMENT_TAG);
        if (current == null) {
            current = pendingSupportRequestManagerFragments.get(fm);
            if (current == null) {
                // 创建SupportRequestManagerFragment
                current = new SupportRequestManagerFragment();
                pendingSupportRequestManagerFragments.put(fm, current);
                // 常见的加入Fragment的方式，利用FragmentManager的一次transaction来commit这个add任务
                fm.beginTransaction().add(current, FRAGMENT_TAG).commitAllowingStateLoss();
                // fragment创建好后，将之前的FragmentManager删除掉，因为已经用不上它了，之前说过，同一个Activity或父Fragment中只会创建一个SupportRequestManagerFragment
                handler.obtainMessage(ID_REMOVE_SUPPORT_FRAGMENT_MANAGER, fm).sendToTarget();
            }
        }
        return current;
    }
}

3） new SupportRequestManagerFragment() 创建空白fragment，主要作用为与RequestManager关联，在它的生命周期方法中回调RequestManager对request生命周期管理的方法，流程图如下

public class SupportRequestManagerFragment extends Fragment {

    private RequestManager requestManager;
    // lifecycle会在创建RequestManager时传入，并在RequestManager构造方法中将requestManager这个LifeCycleListener add到lifeCycle中
    private final ActivityFragmentLifecycle lifecycle;


    public SupportRequestManagerFragment() {
        // 创建LifeCycle，并传入
        this(new ActivityFragmentLifecycle());
    }

    @SuppressLint("ValidFragment")
    public SupportRequestManagerFragment(ActivityFragmentLifecycle lifecycle) {
        this.lifecycle = lifecycle;
    }
}

4） new ActivityFragmentLifecycle(), 实现了LifeCycle接口，回调LifeCycleListener中的onStart(), onStop(), onDestroy()方法, 如下

class ActivityFragmentLifecycle implements Lifecycle {
    @Override
    public void addListener(LifecycleListener listener) {
        lifecycleListeners.add(listener);

        if (isDestroyed) {
            listener.onDestroy();
        } else if (isStarted) {
            listener.onStart();
        } else {
            listener.onStop();
        }
    }

}

5）new RequestManager(context, current.getLifecycle(), current.getRequestManagerTreeNode())
将空白fragment的lifeCycle传入，并将RequestManager这个listener添加到lifeCycle中，从而实现绑定。如下

public class RequestManager implements LifecycleListener {

    // addListener()方式管理LifecycleListener，从而提供对request生命周期管理
    private final Lifecycle lifecycle;
    // request队列，以队列的方式管理request的add remove restart等
    private final RequestTracker requestTracker;

    // 构造方法
    RequestManager(Context context, final Lifecycle lifecycle, RequestManagerTreeNode treeNode,
            RequestTracker requestTracker, ConnectivityMonitorFactory factory) {
        // 省略一段代码
        // RequestManager和lifeCycle关联的关键点  
        if (Util.isOnBackgroundThread()) {
            new Handler(Looper.getMainLooper()).post(new Runnable() {
                @Override
                public void run() {
                    // 将RequestManager加入到lifecycle中，从而回调LifeCycleListener时可以回调到RequestManager中的request生命周期管理方法
                    lifecycle.addListener(RequestManager.this);
                }
            });
        } else {
            lifecycle.addListener(this);
        }
        lifecycle.addListener(connectivityMonitor);
    }
}

3 生命周期回调流程

SupportRequestManagerFragment生命周期中会回调RequestManager对Request管理的相关方法，如下

1）SupportRequestManagerFragment的生命周期方法，如下

public class SupportRequestManagerFragment extends Fragment {
    @Override
    public void onAttach(Activity activity) {
        super.onAttach(activity);
        rootRequestManagerFragment = RequestManagerRetriever.get()
                .getSupportRequestManagerFragment(getActivity().getSupportFragmentManager());
        if (rootRequestManagerFragment != this) {
            rootRequestManagerFragment.addChildRequestManagerFragment(this);
        }
    }

    @Override
    public void onDetach() {
        super.onDetach();
        if (rootRequestManagerFragment != null) {
            rootRequestManagerFragment.removeChildRequestManagerFragment(this);
            rootRequestManagerFragment = null;
        }
    }

    @Override
    public void onStart() {
        super.onStart();
        // 回调lifecycle中方法
        lifecycle.onStart();
    }

    @Override
    public void onStop() {
        super.onStop();
        lifecycle.onStop();
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        lifecycle.onDestroy();
    }

    @Override
    public void onLowMemory() {
        super.onLowMemory();
        // If an activity is re-created, onLowMemory may be called before a manager is ever set.
        // See #329.
        if (requestManager != null) {
            requestManager.onLowMemory();
        }
    }
}

2） 以onStart为例说明生命周期管理流程。ActivityFragmentLifecycle中的onStart如下

class ActivityFragmentLifecycle implements Lifecycle {

    void onStart() {
        isStarted = true;
        for (LifecycleListener lifecycleListener : Util.getSnapshot(lifecycleListeners)) {
            // 回调lifeCycleListener中的相关方法，RequestManager就是一个lifeCycleListener，故可以回调到它里面的对request生命周期进行管理的方法
            lifecycleListener.onStart();
        }
    }
}

3） 在绑定阶段，RequestManager的构造方法中，将RequestManager加入到了lifeCycle中，故上面的lifeCycleListener即为RequestManager，查看RequestManager中相关方法如下

public class RequestManager implements LifecycleListener {

    public void resumeRequests() {
        Util.assertMainThread();
        // 调用requestTracker队列，resume所有的requests
        requestTracker.resumeRequests();
    }

    @Override
    public void onStart() {
        // Activity或Fragment onStart时被回调，此时会resume所有的requests
        resumeRequests();
    }
}

4 总结

Glide中巧妙的用一个空白Fragment来实现了生命周期调用，并使用LifeCycleListener来回调相应的request管理方法。设计模式上也很规范，是一个典型的MVC，SupportRequestManagerFragment用来接入生命周期方法，RequestManager用来实现生命周期中处理request的方法，RequestManagerRetriever用来绑定二者，作为桥梁。我们在网络请求request中同样可以用此方法来实现生命周期绑定。