Android_Glide源码分析

Android_Glide源码分析

---

本文由 Luzhuo 编写,转发请保留该信息.
原文: http://blog.csdn.net/Rozol/article/details/73252999

---

Glide源码讲解

基本使用

Glide.with(this).load(url).into(imageview);

源码讲解

1. 看下.with(this)做了什么

   public static RequestManager with(Context context) {
       RequestManagerRetriever retriever = RequestManagerRetriever.get();
       return retriever.get(context);
   }
   
   public RequestManager get(Context context) {
       if (context == null) {
           throw new IllegalArgumentException("You cannot start a load on a null Context");
       } else if (Util.isOnMainThread() && !(context instanceof Application)) { // ←←←
           if (context instanceof FragmentActivity) {
               return get((FragmentActivity) context);
           } else if (context instanceof Activity) {
               return get((Activity) context);
           } else if (context instanceof ContextWrapper) {
               return get(((ContextWrapper) context).getBaseContext());
           }
       }
   
       return getApplicationManager(context);
   }
   
   @TargetApi(Build.VERSION_CODES.HONEYCOMB)
   public RequestManager get(Activity activity) {
       if (Util.isOnBackgroundThread() || Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB) {
           return get(activity.getApplicationContext());
       } else {
           assertNotDestroyed(activity); // ←←←
           android.app.FragmentManager fm = activity.getFragmentManager(); // ←←←
           return fragmentGet(activity, fm);
       }
   }
   
   @TargetApi(Build.VERSION_CODES.HONEYCOMB)
   RequestManager fragmentGet(Context context, android.app.FragmentManager fm) {
       RequestManagerFragment current = getRequestManagerFragment(fm); // ←←←
       RequestManager requestManager = current.getRequestManager();
       if (requestManager == null) {
           requestManager = new RequestManager(context, current.getLifecycle(), current.getRequestManagerTreeNode());
           current.setRequestManager(requestManager);
       }
       return requestManager;
   }
   
   @TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR1)
   RequestManagerFragment getRequestManagerFragment(final android.app.FragmentManager fm) {
       RequestManagerFragment current = (RequestManagerFragment) fm.findFragmentByTag(FRAGMENT_TAG);
       if (current == null) {
           current = pendingRequestManagerFragments.get(fm);
           if (current == null) {
               current = new RequestManagerFragment();
               pendingRequestManagerFragments.put(fm, current);
               fm.beginTransaction().add(current, FRAGMENT_TAG).commitAllowingStateLoss();
               handler.obtainMessage(ID_REMOVE_FRAGMENT_MANAGER, fm).sendToTarget();
           }
       }
       return current;
   }

   • 先调用Util.isOnMainThread()判断是否在主线程

     public static boolean isOnMainThread() {
         return Looper.myLooper() == Looper.getMainLooper();
     }

      - 判断是否在主线程,原来是通过判断是否是主线程的Looper来判断的
     

   • 先调用assertNotDestroyed(activity)断言Activity还没有Destroy, 然后调用activity.getFragmentManager()获得一个FragmentManager

   • 调用getRequestManagerFragment(fm)获得RequestManagerFragment, 这个其实是一个用于实现生命周期管理的Fragment, 通过Fragment的回调管理RequestManager

     public class RequestManagerFragment extends Fragment {
            
         @SuppressLint("ValidFragment")
         RequestManagerFragment(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();
         }
     }

     • 可见RequestManager实现了LifecycleListener

       public class RequestManager implements LifecycleListener {
                
           RequestManager(Context context, final Lifecycle lifecycle, RequestManagerTreeNode treeNode,
                   RequestTracker requestTracker, ConnectivityMonitorFactory factory) {
               this.context = context.getApplicationContext();
               this.lifecycle = lifecycle;
               this.treeNode = treeNode;
               this.requestTracker = requestTracker;
               this.glide = Glide.get(context);
               this.optionsApplier = new OptionsApplier();
       
               ConnectivityMonitor connectivityMonitor = factory.build(context,
                       new RequestManagerConnectivityListener(requestTracker));
       
               // If we're the application level request manager, we may be created on a background thread. In that case we
               // cannot risk synchronously pausing or resuming requests, so we hack around the issue by delaying adding
               // ourselves as a lifecycle listener by posting to the main thread. This should be entirely safe.
               if (Util.isOnBackgroundThread()) {
                   new Handler(Looper.getMainLooper()).post(new Runnable() {
                       @Override
                       public void run() {
                           lifecycle.addListener(RequestManager.this);
                       }
                   });
               } else {
                   lifecycle.addListener(this);
               }
               lifecycle.addListener(connectivityMonitor);
           }
       
           @Override
           public void onStart() {
               // onStart might not be called because this object may be created after the fragment/activity's onStart method.
               resumeRequests();
           }
       
           @Override
           public void onStop() {
               pauseRequests();
           }
       
           @Override
           public void onDestroy() {
               requestTracker.clearRequests();
           }
       }

2. 上面我们得到了RequestManager的对象,接着调用.load(url)

   public DrawableTypeRequest<String> load(String string) {
       return (DrawableTypeRequest<String>) fromString().load(string);
   }
   
   @Override
   public DrawableRequestBuilder<ModelType> load(ModelType model) {
       super.load(model);
       return this;
   }
   
   public GenericRequestBuilder<ModelType, DataType, ResourceType, TranscodeType> load(ModelType model) {
       this.model = model;
       isModelSet = true;
       return this;
   }

   • 这个很简单,就是给GenericRequestBuilder初始化值, 并返回了DrawableRequestBuilder

3. 接着看.into(imageview)

   @Override
   public Target<GlideDrawable> into(ImageView view) {
       return super.into(view);
   }
   
   public <Y extends Target<TranscodeType>> Y into(Y target) {
      Util.assertMainThread();
      if (target == null) {
          throw new IllegalArgumentException("You must pass in a non null Target");
      }
      if (!isModelSet) {
          throw new IllegalArgumentException("You must first set a model (try #load())");
      }
   
   // ↓↓↓
      Request previous = target.getRequest();
   
      if (previous != null) {
          previous.clear();
          requestTracker.removeRequest(previous);
          previous.recycle();
      }
   
   // ↓↓↓
      Request request = buildRequest(target);
      target.setRequest(request);
      lifecycle.addListener(target);
      requestTracker.runRequest(request);
   
      return target;
   }

   • Request previous = target.getRequest()获取就的Request,如果有就删除他, 然后(buildRequest(target))构建新的Request, 进行绑定与(requestTracker.runRequest(request))发起请求, 并返回Target

   • requestTracker.runRequest(request)是如何执行的呢?

     public class RequestTracker {
            
         private final Set<Request> requests = Collections.newSetFromMap(new WeakHashMap<Request, Boolean>());
         private final List<Request> pendingRequests = new ArrayList<Request>();
         private boolean isPaused;
     
         public void runRequest(Request request) {
             requests.add(request); // ←←←
             if (!isPaused) {
                 request.begin(); // ←←←
             } else {
                 pendingRequests.add(request);
             }
         }
     }
     
     public final class GenericRequest<A, T, Z, R> implements Request, SizeReadyCallback, ResourceCallback {
            
         @Override
         public void begin() {
             startTime = LogTime.getLogTime();
             if (model == null) {
                 onException(null);
                 return;
             }
     
             status = Status.WAITING_FOR_SIZE;
             if (Util.isValidDimensions(overrideWidth, overrideHeight)) {
                 onSizeReady(overrideWidth, overrideHeight); // ←←←
             } else {
                 target.getSize(this);
             }
     
             if (!isComplete() && !isFailed() && canNotifyStatusChanged()) {
                 target.onLoadStarted(getPlaceholderDrawable()); // ←←←
             }
             if (Log.isLoggable(TAG, Log.VERBOSE)) {
                 logV("finished run method in " + LogTime.getElapsedMillis(startTime));
             }
         }
     
         @Override
         public void onSizeReady(int width, int height) {
             if (Log.isLoggable(TAG, Log.VERBOSE)) {
                 logV("Got onSizeReady in " + LogTime.getElapsedMillis(startTime));
             }
             if (status != Status.WAITING_FOR_SIZE) {
                 return;
             }
             status = Status.RUNNING; // ←←←
     
             width = Math.round(sizeMultiplier * width);
             height = Math.round(sizeMultiplier * height);
     
             ModelLoader<A, T> modelLoader = loadProvider.getModelLoader();
             final DataFetcher<T> dataFetcher = modelLoader.getResourceFetcher(model, width, height);
     
             if (dataFetcher == null) {
                 onException(new Exception("Failed to load model: \'" + model + "\'"));
                 return;
             }
             ResourceTranscoder<Z, R> transcoder = loadProvider.getTranscoder();
             if (Log.isLoggable(TAG, Log.VERBOSE)) {
                 logV("finished setup for calling load in " + LogTime.getElapsedMillis(startTime));
             }
             loadedFromMemoryCache = true;
             // ↓↓↓
             loadStatus = engine.load(signature, width, height, dataFetcher, loadProvider, transformation, transcoder,
                     priority, isMemoryCacheable, diskCacheStrategy, this);
             loadedFromMemoryCache = resource != null;
             if (Log.isLoggable(TAG, Log.VERBOSE)) {
                 logV("finished onSizeReady in " + LogTime.getElapsedMillis(startTime));
             }
         }
     }

     • 调用’request.begin()’执行请求, 状态改为Status.WAITING_FOR_SIZE,并调用onSizeReady(overrideWidth, overrideHeight)将状态改为Status.RUNNING,计算了一个四舍五入的宽高,然后将engine.load()发起了请求

     • loadStatus = engine.load(signature, width, height, dataFetcher, loadProvider, transformation, transcoder,
priority, isMemoryCacheable, diskCacheStrategy, this);里做了什么?

       public <T, Z, R> LoadStatus load(Key signature, int width, int height, DataFetcher<T> fetcher,
           DataLoadProvider<T, Z> loadProvider, Transformation<Z> transformation, ResourceTranscoder<Z, R> transcoder,
           Priority priority, boolean isMemoryCacheable, DiskCacheStrategy diskCacheStrategy, ResourceCallback cb) {
       Util.assertMainThread();
       long startTime = LogTime.getLogTime();
       
       final String id = fetcher.getId();
       EngineKey key = keyFactory.buildKey(id, signature, width, height, loadProvider.getCacheDecoder(),
               loadProvider.getSourceDecoder(), transformation, loadProvider.getEncoder(),
               transcoder, loadProvider.getSourceEncoder());
       
       EngineResource<?> cached = loadFromCache(key, isMemoryCacheable); // ←←←
       if (cached != null) {
           cb.onResourceReady(cached);
           if (Log.isLoggable(TAG, Log.VERBOSE)) {
               logWithTimeAndKey("Loaded resource from cache", startTime, key);
           }