Detailed explanation of Glide life cycle management mechanism for advanced Android source code

[[421375]]

This article is reprinted from the WeChat public account "Android Development Programming", the author is Android Development Programming. Please contact the Android Development Programming public account for reprinting this article.

Preface

We have analyzed the glide cache strategy;

We have also analyzed the glide loading process in the previous article;

So this time let's analyze the details of Glide life cycle management

1. Detailed explanation of the Glide life cycle principle

 Glide.with ( this)
 // .asBitmap()//Only static images are allowed to be loaded. If a gif image is passed in, the first frame will be displayed (before loading )
 // .asGif()//Specify the gif format (before loading )
 // .asDrawable()//Specify the drawable format (before loading )
 .load (imageUrl) // URL address of the loaded image
 .placeholder(R.drawable.ic_placeholder)//Placeholder image
 .error(R.drawable.ic_error) // Error picture
 .transition(GenericTransitionOptions. with (R.anim.zoom_in)) //Picture animation
 .override(800,800) //Set loading size
 .skipMemoryCache( true ) //Disable memory cache function
 .diskCacheStrategy(DiskCacheStrategy.NONE) //Do not cache anything
 // .diskCacheStrategy(DiskCacheStrategy.DATA)//Only cache the original image
 // .diskCacheStrategy(DiskCacheStrategy.RESOURCE)//Only cache converted images
 // .diskCacheStrategy(DiskCacheStrategy. ALL )//Cache all
 // .diskCacheStrategy(DiskCacheStrategy.AUTOMATIC)//Glide intelligently chooses which cache strategy to use based on image resources (default)
 .listener(new RequestListener<Drawable>() {//Listen to the image loading status
 //Image loading completed
 @Override
 public boolean onLoadFailed(@Nullable GlideException e, Object model, Target<Drawable> target, boolean isFirstResource) {
 return   false ;
 }
 //Image loading failed
 @Override
 public boolean onResourceReady(Drawable resource, Object model, Target<Drawable> target, DataSource dataSource, boolean isFirstResource) {
 return   false ;
 }
 })
 . into (imageView); //Where the image will eventually be displayed

1. Glide.with(this)

The with method can accept different types of Context, Activity, FragmentActivity, Fragment and View

 private static volatile Glide glide;
 public   static Glide get(@NonNull Context context) {
 if (glide == null ) {
        synchronized (Glide.class) {
            if (glide == null ) {
                checkAndInitializeGlide(context);
 }
 }
 }
 return glide;
 }

The double-check singleton pattern (DCL) ensures the uniqueness of the Glide object. Glide is initialized in the get method, and a GlideBuilder object is created through the builder pattern (resource request thread pool, local cache loading thread pool, animation thread pool, memory cache, disk cache tool, etc.);

After constructing RequestManagerRetriever, return a RequestManager through get (taking Activity as an example);

 //Get RequestManager through Activity
 public RequestManager get(@NonNull Activity activity) {
    if (Util.isOnBackgroundThread()) {
 //If it is a child thread, use the Application level context, that is, no life cycle management
 return get(activity.getApplicationContext());
 } else {
 // Check if the Activity is destroyed
      assertNotDestroyed(activity)
 //Get the FragmentManager of the current Activity
      android.app.FragmentManager fm = activity.getFragmentManager();
 //Generate a Fragment to bind a request manager RequestManager
 return fragmentGet(
          activity, fm, /*parentHint=*/ null , isActivityVisible(activity));
 }
 }

If the current thread is a child thread, there is no need to manage the Glide life cycle. Otherwise, create a fragment through the fragmentGet function:

 private RequestManager fragmentGet(@NonNull Context context,
     @NonNull android.app.FragmentManager fm,
     @Nullable android.app.Fragment parentHint,
     boolean isParentVisible) {
 //①Add a Fragment to the current Activity to manage the request life cycle
   RequestManagerFragment current = getRequestManagerFragment(fm, parentHint, isParentVisible);
 //Get RequestManager
   RequestManager requestManager = current .getRequestManager();
 //If RequestManager does not exist, create it
   if (requestManager == null ) {
     Glide glide = Glide.get(context);
 //②Build RequestManager
 // current .getGlideLifecycle() is the ActivityFragmentLifecycle, which is the ActivityFragmentLifecycle in the fragment that will be passed in when building RequestManager
 requestManager =
 factory.build(
             glide, current .getGlideLifecycle(), current .getRequestManagerTreeNode(), context);
 //Bind the constructed RequestManager to the fragment
 current .setRequestManager(requestManager);
 }
 //Return the manager of the current request
 return requestManager;
 }

2. Binding of Fragment and Activity -> getRequestManagerFragment:

 private RequestManagerFragment getRequestManagerFragment(
      @NonNull final android.app.FragmentManager fm,
      @Nullable android.app.Fragment parentHint,
      boolean isParentVisible) {
 //Get the instantiated fragment through TAG (that is, the same Activity Glide. with multiple times, there is no need to create multiple fragments)
    RequestManagerFragment current = (RequestManagerFragment) fm.findFragmentByTag(FRAGMENT_TAG);
 if ( current == null ) {
 //If the current Activity does not have a fragment for managing the lifecycle, then get it from the cache
 current = pendingRequestManagerFragments.get(fm);
      if ( current == null ) {
 //If there is no cache, just create a new one
 current = new RequestManagerFragment();
 current .setParentFragmentHint(parentHint);
        if (isParentVisible) {
 //Execute the request
 current .getGlideLifecycle().onStart();
 }
 //Add to Map cache (to prevent duplicate creation of fragments)
        pendingRequestManagerFragments.put(fm, current );
 //Bind the fragment to the activity
        fm.beginTransaction(). add ( current , FRAGMENT_TAG).commitAllowingStateLoss();
 //Send and clear cache after adding
        handler.obtainMessage(ID_REMOVE_FRAGMENT_MANAGER, fm).sendToTarget();
 }
 }
 return   current ;
 }

3. Build RequestManager and set up monitoring

 //This factory is to construct the RequestManager object
 private static final RequestManagerFactory DEFAULT_FACTORY = new RequestManagerFactory() {
 @NonNull
 @Override
 public RequestManager build(@NonNull Glide glide, @NonNull Lifecycle lifecycle,
        @NonNull RequestManagerTreeNode requestManagerTreeNode, @NonNull Context context) {
 //Instantiate a RequestManager
 return new RequestManager(glide, lifecycle, requestManagerTreeNode, context);
 }
 };
 public class RequestManager implements LifecycleListener,
    ModelTypes<RequestBuilder<Drawable>> {
 RequestManager(
 Glide glide,
 Lifecycle lifecycle,
      RequestManagerTreeNode treeNode,
      RequestTracker requestTracker,
      ConnectivityMonitorFactory factory,
 Context context) {
 this.glide = glide;
    this.lifecycle = lifecycle;
 this.treeNode = treeNode;
    this.requestTracker = requestTracker;
 this.context = context;
 connectivityMonitor =
 factory.build(
            context.getApplicationContext(),
            new RequestManagerConnectivityListener(requestTracker));
 //Add life cycle monitoring
    if (Util.isOnBackgroundThread()) {
 //The child thread registers the current object to ActivityFragmentLifecycle through the handler
      mainHandler.post(addSelfToLifecycle);
 } else {
 //Register the current object to ActivityFragmentLifecycle
      lifecycle.addListener(this);
 }
 //Add a listener for network changes
    lifecycle.addListener(connectivityMonitor);
 defaultRequestListeners =
        new CopyOnWriteArrayList<>(glide.getGlideContext().getDefaultRequestListeners());
    setRequestOptions(glide.getGlideContext().getDefaultRequestOptions());
    glide.registerRequestManager(this);
 }
 //...
 //RequestManager implements the fragment life cycle callback
 @Override
 public synchronized void onStart() {
 resumeRequests();
 targetTracker.onStart();
 }
 @Override
 public synchronized void onStop() {
 pauseRequests();
 targetTracker.onStop();
 }
 @Override
 public synchronized void onDestroy() {
    targetTracker.onDestroy();
 for (Target<?> target : targetTracker.getAll()) {
 clear(target);
 }
 targetTracker.clear();
    requestTracker.clearRequests();
    lifecycle.removeListener(this);
    lifecycle.removeListener(connectivityMonitor);
    mainHandler.removeCallbacks(addSelfToLifecycle);
    glide.unregisterRequestManager(this);
 }
 }

When building RequestManager, the life cycle of RequestManager is associated with Fragment;

4. Fragment is attached to Activity, so the life cycle of Activity is in Fragment. Next, let's look at RequestManagerFragment:

 public class RequestManagerFragment extends Fragment {
 //The key to the life cycle is ActivityFragmentLifecycle
  private final ActivityFragmentLifecycle lifecycle;
 public RequestManagerFragment() {
    this(new ActivityFragmentLifecycle());
 }
  RequestManagerFragment(@NonNull ActivityFragmentLifecycle lifecycle) {
    this.lifecycle = lifecycle;
 }
 @Override
 public void onStart() {
 super.onStart();
 lifecycle.onStart();
 }
 @Override
 public void onStop() {
 super.onStop();
 lifecycle.onStop();
 }
 @Override
 public void onDestroy() {
 super.onDestroy();
 lifecycle.onDestroy();
    unregisterFragmentWithRoot();
 }
 //...
 }

The key to the life cycle lies in the lifecycle. When the Fragment life cycle changes, it will actively notify the lifecycle to execute the corresponding method;

Next, look at ActivityFragmentLifecycle:

 class ActivityFragmentLifecycle implements Lifecycle {
 //When the Fragment life cycle changes, all its Listeners will be notified
  private final Set <LifecycleListener> lifecycleListeners =
      Collections.newSetFromMap(new WeakHashMap<LifecycleListener, Boolean>());
 private boolean isStarted;
  private boolean isDestroyed;
 @Override
 public void addListener(@NonNull LifecycleListener listener) {
    lifecycleListeners.add (listener) ;
 if (isDestroyed) {
 listener.onDestroy();
 } else if (isStarted) {
 listener.onStart();
 } else {
 listener.onStop();
 }
 }
 @Override
 public void removeListener(@NonNull LifecycleListener listener) {
    lifecycleListeners.remove(listener);
 }
 void onStart() {
 isStarted = true ;
 for (LifecycleListener lifecycleListener : Util.getSnapshot(lifecycleListeners)) {
      lifecycleListener.onStart();
 }
 }
 void onStop() {
 isStarted = false ;
 for (LifecycleListener lifecycleListener : Util.getSnapshot(lifecycleListeners)) {
      lifecycleListener.onStop();
 }
 }
 void onDestroy() {
 isDestroyed = true ;
 for (LifecycleListener lifecycleListener : Util.getSnapshot(lifecycleListeners)) {
      lifecycleListener.onDestroy();
 }
 }
 }

This ActivityFragmentLifecycle holds a lifecycleListeners, which notifies all its Listeners when the Fragment lifecycle changes.

Glide.with(this) binds the lifecycle of the Activity. A new UI-less Fragment is created in the Activity. This Fragment holds a Lifecycle, and the Lifecycle notifies the RequestManager to perform related operations at the key lifecycles of the Fragment. The loading continues during onStart of the lifecycle, the loading is paused during onStop, and the loading task and clearing operations are stopped during onDestory.

2. How does Glide monitor network changes

When constructing RequestManager, add a listener for network changes through lifecycle.addListener(connectivityMonitor);. Changes in the Fragment lifecycle will notify the corresponding method in the default implementation class DefaultConnectivityMonitor. RegisterReceiver in onStart (register to listen to the broadcast of mobile network changes), and unregisterReceiver in onStop. Restart the request after the network is reconnected.

 final class DefaultConnectivityMonitor implements ConnectivityMonitor {
  private static final String TAG = "ConnectivityMonitor" ;
  private final Context context;
  @SuppressWarnings( "WeakerAccess" ) @Synthetic final ConnectivityListener listener;
  @SuppressWarnings( "WeakerAccess" ) @Synthetic boolean isConnected;
  private boolean isRegistered;
  private final BroadcastReceiver connectivityReceiver = new BroadcastReceiver() {
 @Override
 public void onReceive(@NonNull Context context, Intent intent) {
      boolean wasConnected = isConnected;
 //Judge the network status
      isConnected = isConnected(context);
      if (wasConnected != isConnected) {
        if (Log.isLoggable(TAG, Log.DEBUG)) {
          Log.d(TAG, "connectivity changed, isConnected: " + isConnected);
 }
        listener.onConnectivityChanged(isConnected);
 }
 }
 };
  DefaultConnectivityMonitor(@NonNull Context context, @NonNull ConnectivityListener listener) {
    this.context = context.getApplicationContext();
 this.listener = listener;
 }
 private void register() {
 if (isRegistered) {
 return ;
 }
    // Initialize isConnected.
    isConnected = isConnected(context);
 try {
 // See #1405
      context.registerReceiver(connectivityReceiver,
          new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION));
 isRegistered = true ;
    } catch (SecurityException e) {
      // See #1417, registering the receiver can throw SecurityException.
      if (Log.isLoggable(TAG, Log.WARN)) {
        Log.w(TAG, "Failed to register" , e);
 }
 }
 }
 private void unregister() {
 if (!isRegistered) {
 return ;
 }
    context.unregisterReceiver(connectivityReceiver);
 isRegistered = false ;
 }
  @SuppressWarnings( "WeakerAccess" )
 @Synthetic
  // Permissions are checked in the factory instead .
  @SuppressLint( "MissingPermission" )
  boolean isConnected(@NonNull Context context) {
    ConnectivityManager connectivityManager =
        Preconditions.checkNotNull(
            (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE));
 NetworkInfo networkInfo;
 try {
      networkInfo = connectivityManager.getActiveNetworkInfo();
    } catch (RuntimeException e) {
     if (Log.isLoggable(TAG, Log.WARN)) {
        Log.w(TAG, "Failed to determine connectivity status when connectivity changed" , e);
 }
 // Default   to   true ;
 return   true ;
 }
 return networkInfo != null && networkInfo.isConnected();
 }
 @Override
 public void onStart() {
 register();
 }
 @Override
 public void onStop() {
 unregister();
 }
 @Override
 public void onDestroy() {
 // Do nothing.
 }
 }

Call back ConnectivityListener's onConnectivityChanged to handle the request

 private class RequestManagerConnectivityListener
      implements ConnectivityMonitor.ConnectivityListener {
    @GuardedBy( "RequestManager.this" )
    private final RequestTracker requestTracker;
    RequestManagerConnectivityListener(@NonNull RequestTracker requestTracker) {
      this.requestTracker = requestTracker;
 }
 @Override
 public void onConnectivityChanged(boolean isConnected) {
 if (isConnected) {
        synchronized (RequestManager.this) {
 //Restart request after network reconnection
          requestTracker.restartRequests();
 }
 }
 }
 }

Summarize

1. Glide features:

• Ease of use
• Highly configurable and adaptable
• Support common image formats (jpg, png, gif, webp)
• Support multiple data sources (network, local, resources, Assets, etc.)
• Efficient caching strategy (supports Memory and Disk image caching, the default Bitmap format uses RGB_565 with small memory)
• Lifecycle integration (automatically manage requests based on the Activity/Fragment lifecycle)
• Efficiently process Bitmap (use BitmapPool to reuse Bitmap, and actively call recycle to recycle the Bitmap that needs to be recycled)

2. There are still many knowledge points about Glide, and we will continue to summarize and share them with you.