for (Patch patch : mPatchs) {
			patchNames = patch.getPatchNames();
			if (patchNames.contains(patchName)) {
				classes = patch.getClasses(patchName);
				mAndFixManager.fix(patch.getFile(), classLoader, classes);
			}
		}

/**
 * fix
 * 
 * @param file
 *            patch file
 * @param classLoader
 *            classloader of class that will be fixed
 * @param classes
 *            classes will be fixed
 */
public synchronized void fix(File file, ClassLoader classLoader,
		List<String> classes) {
	
	    .......省略........
           //load dex文件
		final DexFile dexFile = DexFile.loadDex(file.getAbsolutePath(),
				optfile.getAbsolutePath(), Context.MODE_PRIVATE);
		if (saveFingerprint) {
			mSecurityChecker.saveOptSig(optfile);
		}
          // 定义自己的classloader
		ClassLoader patchClassLoader = new ClassLoader(classLoader) {
			@Override
			protected Class<?> findClass(String className)
					throws ClassNotFoundException {
				Class<?> clazz = dexFile.loadClass(className, this);
				if (clazz == null
						&& className.startsWith("com.alipay.euler.andfix")) {
					return Class.forName(className);// annotation’s class
													// not found
				}
				if (clazz == null) {
					throw new ClassNotFoundException(className);
				}
				return clazz;
			}
		};
		Enumeration<String> entrys = dexFile.entries();
		Class<?> clazz = null;
		while (entrys.hasMoreElements()) {
			String entry = entrys.nextElement();
			if (classes != null && !classes.contains(entry)) {
				continue;// skip, not need fix
			}
			clazz = dexFile.loadClass(entry, patchClassLoader);
			if (clazz != null) {
				fixClass(clazz, classLoader);
			}
		}
	} catch (IOException e) {
		Log.e(TAG, "pacth", e);
	}
}

private void fixClass(Class<?> clazz, ClassLoader classLoader) {
	Method[] methods = clazz.getDeclaredMethods();
	MethodReplace methodReplace;
	String clz;
	String meth;
	for (Method method : methods) {
		methodReplace = method.getAnnotation(MethodReplace.class);
		if (methodReplace == null)
			continue;
		clz = methodReplace.clazz();
		meth = methodReplace.method();
		if (!isEmpty(clz) && !isEmpty(meth)) {
			replaceMethod(classLoader, clz, meth, method);
		}
	}
}

extern void __attribute__ ((visibility ("hidden"))) dalvik_replaceMethod(
		JNIEnv* env, jobject src, jobject dest) {
	jobject clazz = env->CallObjectMethod(dest, jClassMethod);
	ClassObject* clz = (ClassObject*) dvmDecodeIndirectRef_fnPtr(
			dvmThreadSelf_fnPtr(), clazz);
	clz->status = CLASS_INITIALIZED;
	Method* meth = (Method*) env->FromReflectedMethod(src);
	Method* target = (Method*) env->FromReflectedMethod(dest);
	LOGD("dalvikMethod: %s", meth->name);
	meth->clazz = target->clazz;
	meth->accessFlags |= ACC_PUBLIC;
	meth->methodIndex = target->methodIndex;
	meth->jniArgInfo = target->jniArgInfo;
	meth->registersSize = target->registersSize;
	meth->outsSize = target->outsSize;
	meth->insSize = target->insSize;
	meth->prototype = target->prototype;
	meth->insns = target->insns;
	meth->nativeFunc = target->nativeFunc;
}

protected Class<?> loadClass(String className, boolean resolve) throws ClassNotFoundException {
       Class<?> clazz = findLoadedClass(className);
       if (clazz == null) {
           ClassNotFoundException suppressed = null;
           try {
               clazz = parent.loadClass(className, false);
           } catch (ClassNotFoundException e) {
               suppressed = e;
           }
           if (clazz == null) {
               try {
                   clazz = findClass(className);
               } catch (ClassNotFoundException e) {
                   e.addSuppressed(suppressed);
                   throw e;
               }
           }
       }
       return clazz;
   }

public static void injectDexAtFirst(String dexPath, String defaultDexOptPath) throws NoSuchFieldException, IllegalAccessException, ClassNotFoundException {
    //新建补丁包的dexclassloader
    DexClassLoader dexClassLoader = new DexClassLoader(dexPath, defaultDexOptPath, dexPath, getPathClassLoader());
    //获取原dex加载列表 
    Object baseDexElements = getDexElements(getPathList(getPathClassLoader()));
    // 新建补丁包dex加载列表
    Object newDexElements = getDexElements(getPathList(dexClassLoader));
    //补丁包插在最前连接成新的dex加载列表
    Object allDexElements = combineArray(newDexElements, baseDexElements);
    Object pathList = getPathList(getPathClassLoader());
    //利用发射修改dalvik.system.BaseDexClassLoader类的pathList中的dexElements属性
    ReflectionUtils.setField(pathList, pathList.getClass(), "dexElements", allDexElements);
}

//当一个ViewHolder从RecyclerView里面消失时调用,不一定是移除，也有可能是move操作
@Override  
    public boolean animateDisappearance(RecyclerView.ViewHolder viewHolder, ItemHolderInfo preLayoutInfo, ItemHolderInfo postLayoutInfo) {  
        return false;  
    }  
  //当一个ViewHolder从RecyclerView里面显示时调用,不一定是新增，也有可能是move操作
    @Override  
    public boolean animateAppearance(RecyclerView.ViewHolder viewHolder, ItemHolderInfo preLayoutInfo, ItemHolderInfo postLayoutInfo) {  
        return false;  
    }  
  //没有调用notify而引起布局的改变，比如滑动
    @Override  
    public boolean animatePersistence(RecyclerView.ViewHolder viewHolder, ItemHolderInfo preLayoutInfo, ItemHolderInfo postLayoutInfo) {  
        return false;  
    }  
  //item发生改变的时候调用
    @Override  
    public boolean animateChange(RecyclerView.ViewHolder oldHolder, RecyclerView.ViewHolder newHolder, ItemHolderInfo preLayoutInfo, ItemHolderInfo postLayoutInfo) {  
        return false;  
    }  
  //统筹RecyclerView中所有的动画，统一启动执行,一般的思路是在前面几个函数调用中放入一个动画列表，在这个函数中统一执行
    @Override  
    public void runPendingAnimations() {  
  
    }  
  //结束某一个item的动画
    @Override  
    public void endAnimation(RecyclerView.ViewHolder item) {  
    }  
  //结束所有的动画
    @Override  
    public void endAnimations() { 
    }  
  //动画是否执行过程中
    @Override  
    public boolean isRunning() {  
        return false;  
}

private void animateRemoveImpl(final RecyclerView.ViewHolder holder) {
    final View view = holder.itemView;
    final ViewPropertyAnimatorCompat animation = ViewCompat.animate(view);
    mRemoveAnimations.add(holder);
    animation.setDuration(getRemoveDuration())
            .alpha(0).setListener(new VpaListenerAdapter() {
        @Override
        public void onAnimationStart(View view) {
            dispatchRemoveStarting(holder);
        }
        @Override
        public void onAnimationEnd(View view) {
            animation.setListener(null);
            ViewCompat.setAlpha(view, 1);
            dispatchRemoveFinished(holder);
            mRemoveAnimations.remove(holder);
            dispatchFinishedWhenDone();
        }
    }).start();
}
private void animateAddImpl(final RecyclerView.ViewHolder holder) {
    final View view = holder.itemView;
    final ViewPropertyAnimatorCompat animation = ViewCompat.animate(view);
    mAddAnimations.add(holder);
    animation.alpha(1).setDuration(getAddDuration()).
            setListener(new VpaListenerAdapter() {
                @Override
                public void onAnimationStart(View view) {
                    dispatchAddStarting(holder);
                }
                @Override
                public void onAnimationCancel(View view) {
                    ViewCompat.setAlpha(view, 1);
                }
                @Override
                public void onAnimationEnd(View view) {
                    animation.setListener(null);
                    dispatchAddFinished(holder);
                    mAddAnimations.remove(holder);
                    dispatchFinishedWhenDone();
                }
            }).start();
}

private void animateRemoveImpl(final RecyclerView.ViewHolder holder) {
    mRemoveAnimations.add(holder);
    final ViewPropertyAnimatorCompat animation = getRemoveAnimator(holder);
    animation.setDuration(getRemoveDuration()).setListener(new VpaListenerAdapter() {
                @Override
                public void onAnimationStart(View view) {
                    dispatchRemoveStarting(holder);
                }
                @Override
                public void onAnimationEnd(View view) {
                    animation.setListener(null);
                    clear(view);
                    dispatchRemoveFinished(holder);
                    mRemoveAnimations.remove(holder);
                    dispatchFinishedWhenDone();
                }
            });
    animation.start();
}
private void animateAddImpl(final RecyclerView.ViewHolder holder) {
    mAddAnimations.add(holder);
    final ViewPropertyAnimatorCompat animation = getAddAnimator(holder);
    animation.setDuration(getAddDuration()).
            setListener(new VpaListenerAdapter() {
                @Override
                public void onAnimationStart(View view) {
                    ViewCompat.setAlpha(view,1);
                    dispatchAddStarting(holder);
                }
                @Override
                public void onAnimationCancel(View view) {
                    clear(view);
                }
                @Override
                public void onAnimationEnd(View view) {
                    animation.setListener(null);
                    dispatchAddFinished(holder);
                    mAddAnimations.remove(holder);
                    dispatchFinishedWhenDone();
                }
            }).start();
}
protected abstract ViewPropertyAnimatorCompat getAddAnimator(RecyclerView.ViewHolder viewHolder);
protected abstract ViewPropertyAnimatorCompat getRemoveAnimator(RecyclerView.ViewHolder viewHolder);
public void clear(View v) {
    ViewCompat.setAlpha(v, 1);
    ViewCompat.setScaleY(v, 1);
    ViewCompat.setScaleX(v, 1);
    ViewCompat.setTranslationY(v, 0);
    ViewCompat.setTranslationX(v, 0);
    ViewCompat.setRotation(v, 0);
    ViewCompat.setRotationY(v, 0);
    ViewCompat.setRotationX(v, 0);
    ViewCompat.setPivotY(v, v.getMeasuredHeight() / 2);
    ViewCompat.setPivotX(v, v.getMeasuredWidth() / 2);
    ViewCompat.animate(v).setInterpolator(null).setStartDelay(0);
}

@Override
protected ViewPropertyAnimatorCompat getAddAnimator(RecyclerView.ViewHolder item) {
    ViewCompat.setTranslationX(item.itemView, -item.itemView.getWidth());
    return ViewCompat.animate(item.itemView).translationX(0);
}
@Override
protected ViewPropertyAnimatorCompat getRemoveAnimator(RecyclerView.ViewHolder item) {
    return ViewCompat.animate(item.itemView).translationX(item.itemView.getWidth());
}

public static abstract class ItemDecoration {
    public void onDraw(Canvas c, RecyclerView parent, State state) {
        onDraw(c, parent);
    }
    @Deprecated
    public void onDraw(Canvas c, RecyclerView parent) {
    }
    public void onDrawOver(Canvas c, RecyclerView parent, State state) {
        onDrawOver(c, parent);
    }
    @Deprecated
    public void onDrawOver(Canvas c, RecyclerView parent) {
    }
    @Deprecated
    public void getItemOffsets(Rect outRect, int itemPosition, RecyclerView parent) {
        outRect.set(0, 0, 0, 0);
    }
    public void getItemOffsets(Rect outRect, View view, RecyclerView parent, State state) {
        getItemOffsets(outRect, ((LayoutParams) view.getLayoutParams()).getViewLayoutPosition(),
                parent);
    }
}

public class Hello {
    @Inject Hello() {  //Inject注解构造函数
    }
    public void say() {
        System.out.println(“hello world”);
    }
}

@Component  //Component组件绑定宿主
public interface HelloComponent {
    void inject(HelloDagger dagger);
}

public class HelloDagger {
    @Inject
    static Hello hello;//声明注入依赖
    public static void main(String[] args) {
        DaggerHelloComponent.create().inject(new HelloDagger());//Dagger默认生成DaggerHelloComponent类，调用inject方法注入对象
        hello.say();  //对象已经初始化了
    }
}

public class Hello {
    private String hello;
    @Inject Hello(String hello) {  //有参构造函数
        this.hello = hello;
    }
    public void say() {
        System.out.println(hello);
    }
}

@Module
public class HelloModule {
    String hello = "hello";
    public HelloModule(String hello) {
        this.hello = hello;
    }
    @Provides Hello getHello(){  //Provides注解返回依赖的对象
        return new Hello(hello);
    }
}

@Component(modules = HelloModule.class)  //绑定依赖对象和宿主
public interface HelloComponent {
    void inject(HelloDagger dagger);
}

public class HelloDagger {
    @Inject
    static Hello hello;
    public static void main(String[] args) {
        DaggerHelloComponent.builder()
                .helloModule(new HelloModule("hello world"))  //创建module对象
                .build()
                .inject(new HelloDagger());//注入
        hello.say();
    }
}

@Nullable private final AnimatedImageFactory mAnimatedImageFactory;
private final Bitmap.Config mBitmapConfig;
private final Supplier<MemoryCacheParams> mBitmapMemoryCacheParamsSupplier; //内存缓存数据的策略
private final CacheKeyFactory mCacheKeyFactory; //缓存键值对的获取
private final Context mContext;
private final boolean mDownsampleEnabled;
private final boolean mDecodeMemoryFileEnabled;
private final FileCacheFactory mFileCacheFactory; // 文件缓存键值对
private final Supplier<MemoryCacheParams> mEncodedMemoryCacheParamsSupplier;  //原码内存缓存参数
private final ExecutorSupplier mExecutorSupplier;  //获取线程池
private final ImageCacheStatsTracker mImageCacheStatsTracker;//Cache埋点工具
@Nullable private final ImageDecoder mImageDecoder; //解码器
private final Supplier<Boolean> mIsPrefetchEnabledSupplier;
private final DiskCacheConfig mMainDiskCacheConfig;//磁盘缓存配置
private final MemoryTrimmableRegistry mMemoryTrimmableRegistry;
private final NetworkFetcher mNetworkFetcher; //网络获取器
@Nullable private final PlatformBitmapFactory mPlatformBitmapFactory;
private final PoolFactory mPoolFactory;
private final ProgressiveJpegConfig mProgressiveJpegConfig;  //渐进图片配置
private final Set<RequestListener> mRequestListeners;
private final boolean mResizeAndRotateEnabledForNetwork;
private final DiskCacheConfig mSmallImageDiskCacheConfig;//小图缓存配置
private final ImagePipelineExperiments mImagePipelineExperiments;
...

ImagePipelineConfig config = ImagePipelineConfig.newBuilder()
    .setBitmapMemoryCacheParamsSupplier(bitmapCacheParamsSupplier)  //bitmap缓存配置
    .setCacheKeyFactory(cacheKeyFactory) //设置缓存键值对
    .setEncodedMemoryCacheParamsSupplier(encodedCacheParamsSupplier)//设置原码内存缓存配置
    .setExecutorSupplier(executorSupplier) //各种线程池
    .setImageCacheStatsTracker(imageCacheStatsTracker)//缓存打点
    .setMainDiskCacheConfig(mainDiskCacheConfig) //主磁盘缓存
    .setMemoryTrimmableRegistry(memoryTrimmableRegistry) 
    .setNetworkFetchProducer(networkFetchProducer)//网络请求配置
    .setPoolFactory(poolFactory)
    .setProgressiveJpegConfig(progressiveJpegConfig)//渐进图片配置
    .setRequestListeners(requestListeners)//请求监听
    .setSmallImageDiskCacheConfig(smallImageDiskCacheConfig)//小图缓存
    .build();
Fresco.initialize(context, config);

/**
 * Layer of memory cache stack responsible for managing eviction of the the cached items.
 *
 * <p> This layer is responsible for LRU eviction strategy and for maintaining the size boundaries
 * of the cached items.
 *
 * <p> Only the exclusively owned elements, i.e. the elements not referenced by any client, can be
 * evicted.
 *
 * @param <K> the key type
 * @param <V> the value type
 */
@ThreadSafe
public class CountingMemoryCache<K, V> implements MemoryCache<K, V>, MemoryTrimmable {
   ...//省略代码
    /** Trims the cache according to the specified trimming strategy and the given trim type. */
  @Override
  public void trim(MemoryTrimType trimType) {
    ArrayList<Entry<K, V>> oldEntries;
    final double trimRatio = mCacheTrimStrategy.getTrimRatio(trimType);
    synchronized (this) {
      int targetCacheSize = (int) (mCachedEntries.getSizeInBytes() * (1 - trimRatio));
      int targetEvictionQueueSize = Math.max(0, targetCacheSize - getInUseSizeInBytes());
      oldEntries = trimExclusivelyOwnedEntries(Integer.MAX_VALUE, targetEvictionQueueSize);
      makeOrphans(oldEntries);
    }
    maybeClose(oldEntries);
    maybeNotifyExclusiveEntryRemoval(oldEntries);
    maybeUpdateCacheParams();
    maybeEvictEntries();
  }
  ...//省略代码
}

public void setImageURI(Uri uri, @Nullable Object callerContext) {
  DraweeController controller = mSimpleDraweeControllerBuilder
      .setCallerContext(callerContext)
      .setUri(uri)
      .setOldController(getController())
      .build();
  setController(controller);
}

mActualImageWrapper = new ForwardingDrawable(mEmptyActualImageDrawable);
int numBackgrounds = (builder.getBackgrounds() != null) ? builder.getBackgrounds().size() : 0;
int numOverlays = (builder.getOverlays() != null) ? builder.getOverlays().size() : 0;
numOverlays += (builder.getPressedStateOverlay() != null) ? 1 : 0;
// layer indices and count
int numLayers = 0;
int backgroundsIndex = numLayers;
numLayers += numBackgrounds;
mPlaceholderImageIndex = numLayers++;
mActualImageIndex = numLayers++;
mProgressBarImageIndex = numLayers++;
mRetryImageIndex = numLayers++;
mFailureImageIndex = numLayers++;
int overlaysIndex = numLayers;
numLayers += numOverlays;
// array of layers
Drawable[] layers = new Drawable[numLayers];
if (numBackgrounds > 0) {
  int index = 0;
  for (Drawable background : builder.getBackgrounds()) {
    layers[backgroundsIndex + index++] = buildBranch(background, null);
  }
}
layers[mPlaceholderImageIndex] = buildBranch(
    builder.getPlaceholderImage(),
    builder.getPlaceholderImageScaleType());
layers[mActualImageIndex] = buildActualImageBranch(
    mActualImageWrapper,
    builder.getActualImageScaleType(),
    builder.getActualImageFocusPoint(),
    builder.getActualImageMatrix(),
    builder.getActualImageColorFilter());
layers[mProgressBarImageIndex] = buildBranch(
    builder.getProgressBarImage(),
    builder.getProgressBarImageScaleType());
layers[mRetryImageIndex] = buildBranch(
    builder.getRetryImage(),
    builder.getRetryImageScaleType());
layers[mFailureImageIndex] = buildBranch(
    builder.getFailureImage(),
    builder.getFailureImageScaleType());
if (numOverlays > 0) {
  int index = 0;
  if (builder.getOverlays() != null) {
    for (Drawable overlay : builder.getOverlays()) {
      layers[overlaysIndex + index++] = buildBranch(overlay, null);
    }
  }
  if (builder.getPressedStateOverlay() != null) {
    layers[overlaysIndex + index] = buildBranch(builder.getPressedStateOverlay(), null);
  }
}

private void attachController() {
  if (mIsControllerAttached) {
    return;
  }
  mEventTracker.recordEvent(Event.ON_ATTACH_CONTROLLER);
  mIsControllerAttached = true;
  if (mController != null &&
      mController.getHierarchy() != null) {
    mController.onAttach();
  }
}

@Override
public void onAttach() {
  mEventTracker.recordEvent(Event.ON_ATTACH_CONTROLLER);
  Preconditions.checkNotNull(mSettableDraweeHierarchy);
  mDeferredReleaser.cancelDeferredRelease(this);
  mIsAttached = true;
  if (!mIsRequestSubmitted) {
    submitRequest(); //发起请求
  }
}

protected void submitRequest() {
  ...........//省略代码
  mDataSource = getDataSource();
 ...........//省略代码
  final DataSubscriber<T> dataSubscriber =
      new BaseDataSubscriber<T>() {
        @Override
        public void onNewResultImpl(DataSource<T> dataSource) {
          ..............//获取图片成功
        }
        @Override
        public void onFailureImpl(DataSource<T> dataSource) {
          ...............//获取图片失败
        }
        @Override
        public void onProgressUpdate(DataSource<T> dataSource) {
          ..............//图片获取过程中
        }
      };
  mDataSource.subscribe(dataSubscriber, mUiThreadImmediateExecutor);
}

@Override
protected DataSource<CloseableReference<CloseableImage>> getDataSource() {
  return mDataSourceSupplier.get();
}

protected Supplier<DataSource<IMAGE>> getDataSourceSupplierForRequest(
    final REQUEST imageRequest,
    final boolean bitmapCacheOnly) {
  final Object callerContext = getCallerContext();
  return new Supplier<DataSource<IMAGE>>() {
    @Override
    public DataSource<IMAGE> get() {
      return getDataSourceForRequest(imageRequest, callerContext, bitmapCacheOnly);
    }
    @Override
    public String toString() {
      return Objects.toStringHelper(this)
          .add("request", imageRequest.toString())
          .toString();
    }
  };
}

@Override
protected DataSource<CloseableReference<CloseableImage>> getDataSourceForRequest(
    ImageRequest imageRequest,
    Object callerContext,
    boolean bitmapCacheOnly) {
  if (bitmapCacheOnly) {
    return mImagePipeline.fetchImageFromBitmapCache(imageRequest, callerContext);
  } else {
    return mImagePipeline.fetchDecodedImage(imageRequest, callerContext);
  }
}