热更新Tinker研究（一）：运行tinker-sample-android
热更新Tinker研究（二）：结合源码学习Dex格式
热更新Tinker研究（三）：加载补丁
热更新Tinker研究（四）：TinkerLoader
热更新Tinker研究（五）：Application的隔离
热更新Tinker研究（六）：TinkerPatchPlugin
热更新Tinker研究（七）：Dex的patch文件生成
热更新Tinker研究（八）：res和so的patch文件生成
热更新Tinker研究（九）：Dex文件的patch
热更新Tinker研究（十）：Res文件的patch
热更新Tinker研究（十一）：so文件的patch

热更新Tinker研究（七）：Dex的patch文件生成

ApkDecoder中的dexPatchDecoder负责dex的patch生成工作，dexPatchDecoder实际上是UniqueDexDiffDecoder类型。这一系列相关的类的关系如下图所示。

BaseDecoder中有三个抽象方法，onAllPatchesStart（）， patch(File oldFile, File newFile)，onAllPatchesEnd()。其中onAllPatchesStart（）表示patch()进行前，patch()是正式的patch方法，onAllPatchesEnd()用于处理patch完成后的后续工作。
UniqueDexDiffDecoder只是在DexDiffDecoder的基础上，用一个list保存处理过的dex，来保证dex文件的唯一性。

整个过程可以分为以下步骤来讲解

一、DexClassesComparator

DexClassesComparator是用于比较dex差异的主要类，其中也几个比较重要的成员变量，

    private final Set<Pattern> patternsOfClassDescToCheck = new HashSet<>();    //检测的集合
    private final Set<Pattern> patternsOfIgnoredRemovedClassDesc = new HashSet<>();     //忽略的集合

检测的集合和忽略的集合可以让我们灵活使用，不同的场景下设置不同的参数。
该类比较重要的比较方法具体原理如下，
首先会将类描述（带包名的类名）按照一定的前面的过滤条件放到对应的集合里面，old和new Dex都会处理，

  // Map classDesc and typeIndex to classInfo
        // and collect typeIndex of classes to check in oldDexes.
        for (Dex oldDex : oldDexGroup.dexes) {
            int classDefIndex = 0;
            for (ClassDef oldClassDef : oldDex.classDefs()) {
                String desc = oldDex.typeNames().get(oldClassDef.typeIndex);
                if (Utils.isStringMatchesPatterns(desc, patternsOfClassDescToCheck)) {
                    if (!oldDescriptorOfClassesToCheck.add(desc)) {
                        throw new IllegalStateException(
                                String.format(
                                        "duplicate class descriptor [%s] in different old dexes.",
                                        desc
                                )
                        );
                    }
                }
                DexClassInfo classInfo = new DexClassInfo(desc, classDefIndex, oldClassDef, oldDex);
                ++classDefIndex;
                oldClassDescriptorToClassInfoMap.put(desc, classInfo);
            }
        }

        // Map classDesc and typeIndex to classInfo
        // and collect typeIndex of classes to check in newDexes.
        for (Dex newDex : newDexGroup.dexes) {
            int classDefIndex = 0;
            for (ClassDef newClassDef : newDex.classDefs()) {
                String desc = newDex.typeNames().get(newClassDef.typeIndex);
                if (Utils.isStringMatchesPatterns(desc, patternsOfClassDescToCheck)) {
                    if (!newDescriptorOfClassesToCheck.add(desc)) {
                        throw new IllegalStateException(
                                String.format(
                                        "duplicate class descriptor [%s] in different new dexes.",
                                        desc
                                )
                        );
                    }
                }
                DexClassInfo classInfo = new DexClassInfo(desc, classDefIndex, newClassDef, newDex);
                ++classDefIndex;
                newClassDescriptorToClassInfoMap.put(desc, classInfo);
            }
        }

然后再是得到被删除的类，其实就是oldDescriptorOfClassesToCheck - newDescriptorOfClassesToCheck，差集部分就是我们需要的。

        //oldDescriptorOfClassesToCheck -  newDescriptorOfClassesToCheck差集
        Set<String> deletedClassDescs = new HashSet<>(oldDescriptorOfClassesToCheck);
        deletedClassDescs.removeAll(newDescriptorOfClassesToCheck);

        for (String desc : deletedClassDescs) {
            // These classes are deleted as we expect to, so we remove them
            // from result.
            if (Utils.isStringMatchesPatterns(desc, patternsOfIgnoredRemovedClassDesc)) {
                logger.i(TAG, "Ignored deleted class: %s", desc);
                continue;
            } else {
                logger.i(TAG, "Deleted class: %s", desc);
            }
            deletedClassInfoList.add(oldClassDescriptorToClassInfoMap.get(desc));
        }

再是找到被增加的类，newDescriptorOfClassesToCheck - oldDescriptorOfClassesToCheck,求差集，

        //被增加的类：newDescriptorOfClassesToCheck - oldDescriptorOfClassesToCheck
        Set<String> addedClassDescs = new HashSet<>(newDescriptorOfClassesToCheck);
        addedClassDescs.removeAll(oldDescriptorOfClassesToCheck);

        for (String desc : addedClassDescs) {
            logger.i(TAG, "Added class: %s", desc);
            addedClassInfoList.add(newClassDescriptorToClassInfoMap.get(desc));
        }

要找到被改变的类，首先要找到两个集合的交集，再进行比对，如果发生了改变，就符合被改变的类的条件，加入集合。

  //被改变的类   求交集
        Set<String> mayBeChangedClassDescs = new HashSet<>(oldDescriptorOfClassesToCheck);
        mayBeChangedClassDescs.retainAll(newDescriptorOfClassesToCheck);

        for (String desc : mayBeChangedClassDescs) {
            DexClassInfo oldClassInfo = oldClassDescriptorToClassInfoMap.get(desc);
            DexClassInfo newClassInfo = newClassDescriptorToClassInfoMap.get(desc);
            switch (compareMode) { //？什么区别？
                case COMPARE_MODE_NORMAL: {
                    if (!isSameClass(
                            oldClassInfo.owner,
                            newClassInfo.owner,
                            oldClassInfo.classDef,
                            newClassInfo.classDef
                    )) {
                        logger.i(TAG, "Changed class: %s", desc);
                        changedClassDescToClassInfosMap.put(
                                desc, new DexClassInfo[]{oldClassInfo, newClassInfo}
                        );
                    }
                    break;
                }
                case COMPARE_MODE_CAUSE_REF_CHANGE_ONLY: {
                    if (isClassChangeAffectedToRef(
                            oldClassInfo.owner,
                            newClassInfo.owner,
                            oldClassInfo.classDef,
                            newClassInfo.classDef
                    )) {
                        logger.i(TAG, "Ref-changed class: %s", desc);
                        changedClassDescToClassInfosMap.put(
                                desc, new DexClassInfo[]{oldClassInfo, newClassInfo}
                        );
                    }
                    break;
                }
            }
        }

二、checkIfExcludedClassWasModifiedInNewDex

主要检测没有被包含差分范围内的类，这里一般就是指设定的loader。这里的检测规则如下，
loader相关类必须存在在oldDex文件中的primary dex,也必须要让它们在新的primary dex中保持一致，
有下面一些情况就会被判断为错误发生：
- primary old dex找不到
- primary new dex找不到
- primary old dex 中不存在loader classes
- primary new dex 中存在loader classes
- loader classes 在primary new dex中不删改
- loader classes 在secondary old dexes中被发现
- loader calsses 在secondary new dexes中被发现

相关检测代码如下，主要是利用DexClassesComparator,这里会把loader classes设置为patternsOfClassDescToCheck。
“`java
boolean isPrimaryDex = isPrimaryDex((oldFile == null ? newFile : oldFile));

                if (isPrimaryDex) {
                    if (oldFile == null) {
                        stmCode = STMCODE_ERROR_PRIMARY_OLD_DEX_IS_MISSING;
                    } else if (newFile == null) {
                        stmCode = STMCODE_ERROR_PRIMARY_NEW_DEX_IS_MISSING;
                    } else {
                        dexCmptor.startCheck(oldDex, newDex);
                        deletedClassInfos = dexCmptor.getDeletedClassInfos();
                        addedClassInfos = dexCmptor.getAddedClassInfos();
                        changedClassInfosMap = dexCmptor.getChangedClassDescToInfosMap();

                        // All loader classes are in new dex, while none of them in old one.
                        //这里正确的情况应该是三个infos都为空
                        //如果deletedClassInfos和changedClassInfosMap为空而addedClassInfos不为空，表示loader classes不全在primary old dex中
                        if (deletedClassInfos.isEmpty() && changedClassInfosMap.isEmpty() && !addedClassInfos.isEmpty()) {
                            stmCode = STMCODE_ERROR_LOADER_CLASS_NOT_IN_PRIMARY_OLD_DEX;
                        } else {
                            if (deletedClassInfos.isEmpty() && addedClassInfos.isEmpty()) {
                                // class descriptor is completely matches, see if any contents changes.
                                if (changedClassInfosMap.isEmpty()) {
                                    stmCode = STMCODE_END;
                                } else {
                                    //如果有改变
                                    stmCode = STMCODE_ERROR_LOADER_CLASS_CHANGED;
                                }
                            } else {
                                //有删除  或者 增加
                                stmCode = STMCODE_ERROR_LOADER_CLASS_IN_PRIMARY_DEX_MISMATCH;
                            }
                        }
                    }
                } else {
                    //后面主要检测loader classes是否存在于secondary dexes
                    Set<Pattern> patternsOfClassDescToCheck = new HashSet<>();
                    for (String patternStr : config.mDexLoaderPattern) {
                        patternsOfClassDescToCheck.add(
                            Pattern.compile(
                                PatternUtils.dotClassNamePatternToDescriptorRegEx(patternStr)
                            )
                        );
                    }

                    if (oldDex != null) {
                        oldClassesDescToCheck.clear();
                        for (ClassDef classDef : oldDex.classDefs()) {
                            String desc = oldDex.typeNames().get(classDef.typeIndex);
                            if (Utils.isStringMatchesPatterns(desc, patternsOfClassDescToCheck)) {
                                oldClassesDescToCheck.add(desc);
                            }
                        }
                        if (!oldClassesDescToCheck.isEmpty()) {
                            stmCode = STMCODE_ERROR_LOADER_CLASS_FOUND_IN_SECONDARY_OLD_DEX;
                            break;
                        }
                    }

                    if (newDex != null) {
                        newClassesDescToCheck.clear();
                        for (ClassDef classDef : newDex.classDefs()) {
                            String desc = newDex.typeNames().get(classDef.typeIndex);
                            if (Utils.isStringMatchesPatterns(desc, patternsOfClassDescToCheck)) {
                                newClassesDescToCheck.add(desc);
                            }
                        }
                        if (!newClassesDescToCheck.isEmpty()) {
                            stmCode = STMCODE_ERROR_LOADER_CLASS_FOUND_IN_SECONDARY_NEW_DEX;
                            break;
                        }
                    }

                    stmCode = STMCODE_END;
                }

“`

三、collectAddedOrDeletedClasses

这里主要是为了得到增加和删除的classes,和DexClassesComparator中原理类似，也是利用两个集合求差集。

  Dex oldDex = new Dex(oldFile);
        Dex newDex = new Dex(newFile);

        Set<String> oldClassDescs = new HashSet<>();
        for (ClassDef oldClassDef : oldDex.classDefs()) {
            oldClassDescs.add(oldDex.typeNames().get(oldClassDef.typeIndex));
        }

        Set<String> newClassDescs = new HashSet<>();
        for (ClassDef newClassDef : newDex.classDefs()) {
            newClassDescs.add(newDex.typeNames().get(newClassDef.typeIndex));
        }

        // newClassDescs - oldClassDescs得到 增加的类
        Set<String> addedClassDescs = new HashSet<>(newClassDescs);
        addedClassDescs.removeAll(oldClassDescs);

        //oldClassDescs - newClassDescs得到 删除的类
        Set<String> deletedClassDescs = new HashSet<>(oldClassDescs);
        deletedClassDescs.removeAll(newClassDescs);

        for (String addedClassDesc : addedClassDescs) {
            if (addedClassDescToDexNameMap.containsKey(addedClassDesc)) {
                throw new TinkerPatchException(
                        String.format(
                                "Class Duplicate. Class [%s] is added in both new dex: [%s] and [%s]. Please check your newly apk.",
                                addedClassDesc,
                                addedClassDescToDexNameMap.get(addedClassDesc),
                                newFile.toString()
                        )
                );
            } else {
                addedClassDescToDexNameMap.put(addedClassDesc, newFile.toString());
            }
        }

        for (String deletedClassDesc : deletedClassDescs) {
            if (deletedClassDescToDexNameMap.containsKey(deletedClassDesc)) {
                throw new TinkerPatchException(
                        String.format(
                                "Class Duplicate. Class [%s] is deleted in both old dex: [%s] and [%s]. Please check your base apk.",
                                deletedClassDesc,
                                addedClassDescToDexNameMap.get(deletedClassDesc),
                                oldFile.toString()
                        )
                );
            } else {
                deletedClassDescToDexNameMap.put(deletedClassDesc, newFile.toString());
            }
        }

四、generatePatchInfoFile

generatePatchedDexInfoFile

根据oldDex和newDex的对应关系，来生成dex_meta.txt中的列表，其中
oldAndNewDexFilePairList保存这oldDex和newDex中的对应关系，具体代码

    private void generatePatchedDexInfoFile() {
        // Generate dex diff out and full patched dex if a pair of dex is different.
        for (AbstractMap.SimpleEntry<File, File> oldAndNewDexFilePair : oldAndNewDexFilePairList) {
            File oldFile = oldAndNewDexFilePair.getKey();
            File newFile = oldAndNewDexFilePair.getValue();
            final String dexName = getRelativeDexName(oldFile, newFile);
            RelatedInfo relatedInfo = dexNameToRelatedInfoMap.get(dexName);
            if (!relatedInfo.oldMd5.equals(relatedInfo.newMd5)) {
                diffDexPairAndFillRelatedInfo(oldFile, newFile, relatedInfo);
            } else {
                // In this case newDexFile is the same as oldDexFile, but we still
                // need to treat it as patched dex file so that the SmallPatchGenerator
                // can analyze which class of this dex should be kept in small patch.
                relatedInfo.newOrFullPatchedFile = newFile;
                relatedInfo.newOrFullPatchedMd5 = relatedInfo.newMd5;
            }
        }
    }

logDexesToDexMeta

这个方法主要是根据前面记录的RelatedInfo，来把dex的patch信息写入dex_meta.txt中，这里会针对不同的情况进行不同的操作，部分代码如下

 for (AbstractMap.SimpleEntry<File, File> oldAndNewDexFilePair : oldAndNewDexFilePairList) {
            final File oldDexFile = oldAndNewDexFilePair.getKey();
            final File newDexFile = oldAndNewDexFilePair.getValue();
            final String dexName = getRelativeDexName(oldDexFile, newDexFile);
            final RelatedInfo relatedInfo = dexNameToRelatedInfoMap.get(dexName);
            if (!relatedInfo.oldMd5.equals(relatedInfo.newMd5)) {
                //logToDexMeta(newDexFile, oldDexFile, relatedInfo.dexDiffFile, relatedInfo.newOrFullPatchedMd5, relatedInfo.smallPatchedMd5, relatedInfo.dexDiffMd5);
                logToDexMeta(newDexFile, oldDexFile, relatedInfo.dexDiffFile, relatedInfo.newOrFullPatchedMd5, relatedInfo.newOrFullPatchedMd5, relatedInfo.dexDiffMd5);
            } else {
                // For class N dexes, if new dex is the same as old dex, we should log it as 'copy directly'
                // in dex meta to fix problems in Art environment.
                if (realClassNDexFiles.contains(oldDexFile)) {
                    //if (!"0".equals(relatedInfo.smallPatchedMd5)) {
                    //    logToDexMeta(newDexFile, oldDexFile, null, "0", relatedInfo.smallPatchedMd5, "0");
                    //}

                    // Bugfix: However, if what we would copy directly is main dex, we should do an additional diff operation
                    // so that patch applier would help us remove all loader classes of it in runtime.
                    if (dexName.equals(DexFormat.DEX_IN_JAR_NAME)) {
                        Logger.d("\nDo additional diff on main dex to remove loader classes in it.");
                        diffDexPairAndFillRelatedInfo(oldDexFile, newDexFile, relatedInfo);
                        logToDexMeta(newDexFile, oldDexFile, relatedInfo.dexDiffFile, relatedInfo.newOrFullPatchedMd5, relatedInfo.newOrFullPatchedMd5, relatedInfo.dexDiffMd5);
                    } else {
                        logToDexMeta(newDexFile, oldDexFile, null, "0", relatedInfo.oldMd5, "0");
                    }
                }
            }
        }

由于md5不同时，前面的方法已经生成了classes.dex等差分文件，这里只需要把差异信息记录到dex_meta.txt中。当md5相同时，对于mainDex，需要移除掉loader classes之后，重新生成比对信息。

五、DexPatchGenerator

dex的差分工作主要在DexPatchGenerator中完成，

public class DexPatchGenerator {
    private static final String TAG = "DexPatchGenerator";

    private final Dex oldDex;
    private final Dex newDex;
    private final DexPatcherLogger logger = new DexPatcherLogger();
    private DexSectionDiffAlgorithm<StringData> stringDataSectionDiffAlg;
    private DexSectionDiffAlgorithm<Integer> typeIdSectionDiffAlg;
    private DexSectionDiffAlgorithm<ProtoId> protoIdSectionDiffAlg;
    private DexSectionDiffAlgorithm<FieldId> fieldIdSectionDiffAlg;
    private DexSectionDiffAlgorithm<MethodId> methodIdSectionDiffAlg;
    private DexSectionDiffAlgorithm<ClassDef> classDefSectionDiffAlg;
    private DexSectionDiffAlgorithm<TypeList> typeListSectionDiffAlg;
    private DexSectionDiffAlgorithm<AnnotationSetRefList> annotationSetRefListSectionDiffAlg;
    private DexSectionDiffAlgorithm<AnnotationSet> annotationSetSectionDiffAlg;
    private DexSectionDiffAlgorithm<ClassData> classDataSectionDiffAlg;
    private DexSectionDiffAlgorithm<Code> codeSectionDiffAlg;
    private DexSectionDiffAlgorithm<DebugInfoItem> debugInfoSectionDiffAlg;
    private DexSectionDiffAlgorithm<Annotation> annotationSectionDiffAlg;
    private DexSectionDiffAlgorithm<EncodedValue> encodedArraySectionDiffAlg;
    private DexSectionDiffAlgorithm<AnnotationsDirectory> annotationsDirectorySectionDiffAlg;
    ......
}

DexSectionDiffAlgorithm

DexSectionDiffAlgorithm负责某一个section的差分工作，

调整dex文件中元素的顺序

在比较两个dex文件差异之前，需要按照固定的顺序去对dex中sectionItem进行排序

        //按照一定的顺序调整  item的位置
        AbstractMap.SimpleEntry<Integer, T>[] adjustedOldIndexedItems = new AbstractMap.SimpleEntry[this.oldItemCount];
        System.arraycopy(this.adjustedOldIndexedItemsWithOrigOrder, 0, adjustedOldIndexedItems, 0, this.oldItemCount);
        Arrays.sort(adjustedOldIndexedItems, this.comparatorForItemDiff);

        AbstractMap.SimpleEntry<Integer, T>[] adjustedNewIndexedItems = collectSectionItems(this.newDex, false);
        this.newItemCount = adjustedNewIndexedItems.length;
        Arrays.sort(adjustedNewIndexedItems, this.comparatorForItemDiff);

其中有这么几个数据结构来保存对应关系，

    /**
     * SparseIndexMap for mapping items between old dex and new dex.
     * e.g. item.oldIndex => item.newIndex
     */
    private final SparseIndexMap oldToNewIndexMap;
    /**
     * SparseIndexMap for mapping items between old dex and patched dex.
     * e.g. item.oldIndex => item.patchedIndex
     */
    private final SparseIndexMap oldToPatchedIndexMap;
    /**
     * SparseIndexMap for mapping items between new dex and patched dex.
     * e.g. item.newIndex => item.newIndexInPatchedDex
     */
    private final SparseIndexMap newToPatchedIndexMap;
        /**
     * SparseIndexMap for mapping items in new dex when skip items.
     */
    private final SparseIndexMap selfIndexMapForSkip;

由于patchedDex和newDex不是完全相同，数据结构以及内容相同，但是排列顺序不一定相同，也就是patchedDex最终合成的dex和newDex的执行效果相同，但是md5不一定要相同，所以这里需要上面这么几个集合来保存oldDex,patchedDex和newDex的对应关系。
调整item顺序之前中有个关键步骤，就是去收集一个dex文件中的item,这里实际就是按照patched需要的顺序去调整oldDex和newDex中的数据结构。

 private AbstractMap.SimpleEntry<Integer, T>[] collectSectionItems(Dex dex, boolean isOldDex) {
        TableOfContents.Section tocSec = getTocSection(dex);
        if (!tocSec.exists()) {
            return EMPTY_ENTRY_ARRAY;
        }
        Dex.Section dexSec = dex.openSection(tocSec);
        int itemCount = tocSec.size;
        List<AbstractMap.SimpleEntry<Integer, T>> result = new ArrayList<>(itemCount);
        if (isOldDex) {
            for (int i = 0; i < itemCount; ++i) {
                T nextItem = nextItem(dexSec);
                T adjustedItem = adjustItem(oldToPatchedIndexMap, nextItem);   //按照patchedDex的顺序来调整
                result.add(new AbstractMap.SimpleEntry<>(i, adjustedItem)); //加入调整后的item
            }
        } else {
            int i = 0;
            while (i < itemCount) {
                T nextItem = nextItem(dexSec);
                int indexBeforeSkip = i;
                int offsetBeforeSkip = getItemOffsetOrIndex(indexBeforeSkip, nextItem);
                int indexAfterSkip = indexBeforeSkip;
                //跳过不需要  考虑的item
                while (indexAfterSkip < itemCount && shouldSkipInNewDex(nextItem)) {
                    if (indexAfterSkip + 1 >= itemCount) {
                        // after skipping last item, nextItem will be null.
                        nextItem = null;
                    } else {
                        nextItem = nextItem(dexSec);
                    }
                    ++indexAfterSkip;
                }
                if (nextItem != null) {
                    int offsetAfterSkip = getItemOffsetOrIndex(indexAfterSkip, nextItem);
                    //adjustItem(selfIndexMapForSkip, nextItem) 按照跳过的关系 拿到item，然后根据newToPatched的关系来调整newDex中item的顺序
                    T adjustedItem = adjustItem(newToPatchedIndexMap, adjustItem(selfIndexMapForSkip, nextItem));
                    int currentOutIndex = result.size();
                    result.add(new AbstractMap.SimpleEntry<>(currentOutIndex, adjustedItem));
                    updateIndexOrOffset(selfIndexMapForSkip, indexBeforeSkip, offsetBeforeSkip, indexAfterSkip, offsetAfterSkip);
                }
                i = indexAfterSkip;
                ++i;
            }
        }
        return result.toArray(new AbstractMap.SimpleEntry[0]);
    }

对比两个调整后dex的item

根据比较的结果把操作的步骤放到patchOperationList中，

    int oldCursor = 0;
        int newCursor = 0;
        while (oldCursor < this.oldItemCount || newCursor < this.newItemCount) {
            if (oldCursor >= this.oldItemCount) {
                // rest item are all newItem.
                //剩余的 全部是newItem内容
                while (newCursor < this.newItemCount) {
                    AbstractMap.SimpleEntry<Integer, T> newIndexedItem = adjustedNewIndexedItems[newCursor++];
                    this.patchOperationList.add(new PatchOperation<>(PatchOperation.OP_ADD, newIndexedItem.getKey(), newIndexedItem.getValue()));
                }
            } else
            if (newCursor >= newItemCount) {
                // rest item are all oldItem. 
                // 剩下的全是oldItem
                while (oldCursor < oldItemCount) {
                    AbstractMap.SimpleEntry<Integer, T> oldIndexedItem = adjustedOldIndexedItems[oldCursor++];
                    int deletedIndex = oldIndexedItem.getKey();
                    int deletedOffset = getItemOffsetOrIndex(deletedIndex, oldIndexedItem.getValue());
                    this.patchOperationList.add(new PatchOperation<T>(PatchOperation.OP_DEL, deletedIndex));
                    markDeletedIndexOrOffset(this.oldToPatchedIndexMap, deletedIndex, deletedOffset);
                }
            } else {
                //比较两者的差异
                AbstractMap.SimpleEntry<Integer, T> oldIndexedItem = adjustedOldIndexedItems[oldCursor];
                AbstractMap.SimpleEntry<Integer, T> newIndexedItem = adjustedNewIndexedItems[newCursor];
                int cmpRes = oldIndexedItem.getValue().compareTo(newIndexedItem.getValue());
                if (cmpRes < 0) {
                    //如果结果小于0  表示被删除
                    int deletedIndex = oldIndexedItem.getKey();
                    int deletedOffset = getItemOffsetOrIndex(deletedIndex, oldIndexedItem.getValue());
                    this.patchOperationList.add(new PatchOperation<T>(PatchOperation.OP_DEL, deletedIndex));
                    markDeletedIndexOrOffset(this.oldToPatchedIndexMap, deletedIndex, deletedOffset);
                    ++oldCursor;
                } else
                if (cmpRes > 0) {
                    //结果大于0  表示被增加
                    this.patchOperationList.add(new PatchOperation<>(PatchOperation.OP_ADD, newIndexedItem.getKey(), newIndexedItem.getValue()));
                    ++newCursor;
                } else {
                    //如果完全一样  只需要建立对应的偏移关系就可以了
                    int oldIndex = oldIndexedItem.getKey();
                    int newIndex = newIndexedItem.getKey();
                    int oldOffset = getItemOffsetOrIndex(oldIndexedItem.getKey(), oldIndexedItem.getValue());
                    int newOffset = getItemOffsetOrIndex(newIndexedItem.getKey(), newIndexedItem.getValue());

                    if (oldIndex != newIndex) {
                        this.oldIndexToNewIndexMap.put(oldIndex, newIndex);
                    }

                    if (oldOffset != newOffset) {
                        this.oldOffsetToNewOffsetMap.put(oldOffset, newOffset);
                    }

                    ++oldCursor;
                    ++newCursor;
                }
            }
        }

patch操作的排序优化

为了让patch操作更加优雅和简洁，需要按照一定顺序进行排序，主要是为了后面的合并步骤，

        //对patch的操作进行排序优化
        Collections.sort(this.patchOperationList, comparatorForPatchOperationOpt);

add和delete进行合并操作

add和delete如果发生在同一个位置，可以合并为replace操作，

  Iterator<PatchOperation<T>> patchOperationIt = this.patchOperationList.iterator();
        PatchOperation<T> prevPatchOperation = null;
        while (patchOperationIt.hasNext()) {
            PatchOperation<T> patchOperation = patchOperationIt.next();
            //对add和del进行replace合并操作
            if (prevPatchOperation != null
                && prevPatchOperation.op == PatchOperation.OP_DEL
                && patchOperation.op == PatchOperation.OP_ADD
            ) {
                if (prevPatchOperation.index == patchOperation.index) {
                    prevPatchOperation.op = PatchOperation.OP_REPLACE;
                    prevPatchOperation.newItem = patchOperation.newItem;
                    patchOperationIt.remove();
                    prevPatchOperation = null;
                } else {
                    prevPatchOperation = patchOperation;
                }
            } else {
                prevPatchOperation = patchOperation;
            }
        }

记录patch过程中的操作

 // Finally we record some information for the final calculations.
        patchOperationIt = this.patchOperationList.iterator();
        while (patchOperationIt.hasNext()) {
            PatchOperation<T> patchOperation = patchOperationIt.next();
            switch (patchOperation.op) {
                case PatchOperation.OP_DEL: {
                    indexToDelOperationMap.put(patchOperation.index, patchOperation);
                    break;
                }
                case PatchOperation.OP_ADD: {
                    indexToAddOperationMap.put(patchOperation.index, patchOperation);
                    break;
                }
                case PatchOperation.OP_REPLACE: {
                    indexToReplaceOperationMap.put(patchOperation.index, patchOperation);
                    break;
                }
            }
        }

模拟patch过程

每次section进行上面的步骤后，都要模拟一次patch过程，主要为了计算patched之后的对应关系和section的size。

    public void simulatePatchOperation(int baseOffset) {
        boolean isNeedToMakeAlign = getTocSection(this.oldDex).isElementFourByteAligned;
        int oldIndex = 0;
        int patchedIndex = 0;
        int patchedOffset = baseOffset;
        while (oldIndex < this.oldItemCount || patchedIndex < this.newItemCount) {
            if (this.indexToAddOperationMap.containsKey(patchedIndex)) {
                PatchOperation<T> patchOperation = this.indexToAddOperationMap.get(patchedIndex);
                if (isNeedToMakeAlign) {
                    patchedOffset = SizeOf.roundToTimesOfFour(patchedOffset);
                }
                T newItem = patchOperation.newItem;
                int itemSize = getItemSize(newItem);
                updateIndexOrOffset(
                        this.newToPatchedIndexMap,
                        0,
                        getItemOffsetOrIndex(patchOperation.index, newItem),
                        0,
                        patchedOffset
                );
                ++patchedIndex;
                patchedOffset += itemSize;
            } else
            if (this.indexToReplaceOperationMap.containsKey(patchedIndex)) {
                PatchOperation<T> patchOperation = this.indexToReplaceOperationMap.get(patchedIndex);
                if (isNeedToMakeAlign) {
                    patchedOffset = SizeOf.roundToTimesOfFour(patchedOffset);
                }
                T newItem = patchOperation.newItem;
                int itemSize = getItemSize(newItem);
                updateIndexOrOffset(
                        this.newToPatchedIndexMap,
                        0,
                        getItemOffsetOrIndex(patchOperation.index, newItem),
                        0,
                        patchedOffset
                );
                ++patchedIndex;
                patchedOffset += itemSize;
            } else
            if (this.indexToDelOperationMap.containsKey(oldIndex)) {
                ++oldIndex;
            } else
            if (this.indexToReplaceOperationMap.containsKey(oldIndex)) {
                ++oldIndex;
            } else
            if (oldIndex < this.oldItemCount) {
                if (isNeedToMakeAlign) {
                    patchedOffset = SizeOf.roundToTimesOfFour(patchedOffset);
                }

                T oldItem = this.adjustedOldIndexedItemsWithOrigOrder[oldIndex].getValue();
                int itemSize = getItemSize(oldItem);

                int oldOffset = getItemOffsetOrIndex(oldIndex, oldItem);

                updateIndexOrOffset(
                        this.oldToPatchedIndexMap,
                        oldIndex,
                        oldOffset,
                        patchedIndex,
                        patchedOffset
                );

                int newIndex = oldIndex;
                if (this.oldIndexToNewIndexMap.containsKey(oldIndex)) {
                    newIndex = this.oldIndexToNewIndexMap.get(oldIndex);
                }

                int newOffset = oldOffset;
                if (this.oldOffsetToNewOffsetMap.containsKey(oldOffset)) {
                    newOffset = this.oldOffsetToNewOffsetMap.get(oldOffset);
                }

                updateIndexOrOffset(
                        this.newToPatchedIndexMap,
                        newIndex,
                        newOffset,
                        patchedIndex,
                        patchedOffset
                );

                ++oldIndex;
                ++patchedIndex;
                patchedOffset += itemSize;
            }
        }

        this.patchedSectionSize = SizeOf.roundToTimesOfFour(patchedOffset - baseOffset);
    }

六、addTestDex

这里会加入test.dex，不进行详述。主要是能够更好地标识这一过程已经完成。