Tinker分析：
什么是tinker？
Tinker是腾讯出的一款热修复框架，可以修复代码，资源文件，so库，但不能新增四大组件。
热修复与增量更新的本质区别：增量更新是根据new.apk和old.apk按照bsdiff算法，生成一个patch，然后将patch通过服务端推送，推送给客户端，客户端下载patch，再使用bsdiff算法，将patch和old.apk生成新的apk，完成升级。需要重新安装。
热修复，是不需要进行重新安装，所以这就导致了热修复是不能新增四大组件的。
Tinker使用：
目前是2种，一种是直接使用tencent提供的gradleproject依赖的方式，直接项目依赖；另一种是使用命令行手动生成patch.下面就说明本地测试的使用命令行的方式进行的demo：
…………后面再说
Tinker源码分析：分2步，首先是生成patch的过程。克隆tencenttinker github源码，目录下的module：tinker-patch-cli就是patch工具的代码。
使用该jar工具的方式，命令行输入：
java -jar tinker-patch-cli-1.7.7.jar -oldold.apk -new new.apk -config tinker_config.xml -out output
private void run(String[] args) {
…………
try {
ReadArgs readArgs = new ReadArgs(args).invoke();//就是生成patch时输入的命令：java-jar tinker-patch-cli-1.7.7.jar -old old.apk -new new.apk -configtinker_config.xml -out output
File configFile = readArgs.getConfigFile();// 配置文件,tinker_config.xml
File outputFile = readArgs.getOutputFile();//
File oldApkFile = readArgs.getOldApkFile();
File newApkFile = readArgs.getNewApkFile();
if (oldApkFile == null || newApkFile == null) {
Logger.e("Missing old apk or new apk file argument");
goToError();
} else if (!oldApkFile.exists() || !newApkFile.exists()) {
Logger.e("Old apk or new apk file does not exist");
goToError();
}
if (outputFile == null) {
outputFile = new File(mRunningLocation, TypedValue.PATH_DEFAULT_OUTPUT);
}
这3个方法是关键，下面进行一一说明。
loadConfigFromXml(configFile, outputFile,oldApkFile, newApkFile);
Logger.initLogger(config);
tinkerPatch();
}catch (IOException e) {
e.printStackTrace();
goToError();
}finally {
Logger.closeLogger();
}
}
loadConfigFromXml(configFile,outputFile, oldApkFile, newApkFile);
整个方法就是生成一个config对象，就相当于把tinker_config.xml转化成一个对象。
下面开始具体的patch生成：tinkerPatch();
protected void tinkerPatch() {
Logger.d("-----------------------Tinker patchbegin-----------------------");
Logger.d(config.toString());
try {
//gen patch
ApkDecoder decoder = new ApkDecoder(config);
decoder.onAllPatchesStart();
decoder.patch(config.mOldApkFile, config.mNewApkFile);
decoder.onAllPatchesEnd();
//gen meta file and version file
PatchInfo info = new PatchInfo(config);
info.gen();
//build patch
PatchBuilder builder = new PatchBuilder(config);
builder.buildPatch();
}catch (Throwable e) {
e.printStackTrace();
goToError();
}
Logger.d("Tinker patch done, total time cost: %fs",diffTimeFromBegin());
Logger.d("Tinker patch done, you can go to file to find the output%s", config.mOutFolder);
Logger.d("-----------------------Tinker patchend-------------------------");
}
ApkDecoder：
publicApkDecoder(Configuration config) throws IOException {
super(config);
this.mNewApkDir = config.mTempUnzipNewDir;
this.mOldApkDir = config.mTempUnzipOldDir;
this.manifestDecoder = new ManifestDecoder(config);
//put meta files in assets
String prePath = TypedValue.FILE_ASSETS + File.separator;
dexPatchDecoder = new UniqueDexDiffDecoder(config, prePath +TypedValue.DEX_META_FILE, TypedValue.DEX_LOG_FILE);
soPatchDecoder = new BsDiffDecoder(config, prePath +TypedValue.SO_META_FILE, TypedValue.SO_LOG_FILE);
resPatchDecoder = new ResDiffDecoder(config, prePath +TypedValue.RES_META_TXT, TypedValue.RES_LOG_FILE);
resDuplicateFiles = newArrayList<>();
}
会发现，针对dex文件，so文件和res文件会生成相应的decoder，这些decoder都继承自BaseDecoder，相当于文件解码器。这些decoder的主要工作都在抽象方法patch（）中实现。
decoder.onAllPatchesStart()和decoder.onAllPatchesEnd()都是空实现，不用分析，下面重点分析：
decoder.patch(config.mOldApkFile, config.mNewApkFile);
public boolean patch(File oldFile, File newFile)throws Exception {
writeToLogFile(oldFile, newFile);//写入log文件，忽略。
//check manifest change first
//主要分析1：
manifestDecoder.patch(oldFile, newFile);
//主要分析2：
unzipApkFiles(oldFile, newFile);
//主要分析3：
Files.walkFileTree(mNewApkDir.toPath(), new ApkFilesVisitor(config,mNewApkDir.toPath(), mOldApkDir.toPath(), dexPatchDecoder, soPatchDecoder,resPatchDecoder));
//get all duplicate resource file
for (File duplicateRes : resDuplicateFiles) {
// resPatchDecoder.patch(duplicateRes, null);
Logger.e("Warning: res file %s is also match at dex or librarypattern, "
+ "we treat it as unchanged in the new resource_out.zip",getRelativePathStringToOldFile(duplicateRes));
}
soPatchDecoder.onAllPatchesEnd();//空实现
dexPatchDecoder.onAllPatchesEnd();//非空实现，需要分析
manifestDecoder.onAllPatchesEnd();//空实现
resPatchDecoder.onAllPatchesEnd();//非空实现，需要分析
//clean resources
dexPatchDecoder.clean();
soPatchDecoder.clean();
resPatchDecoder.clean();
return true;
}
主要分析1：先看ManifestDecoder的patch（）：
@Override
publicboolean patch(File oldFile, File newFile) throws IOException,TinkerPatchException {
try {
//这2个方法涉及到解析编译后的AndroidManifest.xml和resource.arsc文件，这是一个非常复杂的工程。就不详细分析了。
AndroidParser oldAndroidManifest = AndroidParser.getAndroidManifest(oldFile);
AndroidParser newAndroidManifest =AndroidParser.getAndroidManifest(newFile);
//check minSdkVersion
int minSdkVersion =Integer.parseInt(oldAndroidManifest.apkMeta.getMinSdkVersion());
if (minSdkVersion < TypedValue.ANDROID_40_API_LEVEL) {
if (config.mDexRaw) {
final StringBuilder sb =new StringBuilder();
sb.append("your oldapk's minSdkVersion ")
.append(minSdkVersion)
.append(" is below14, you should set the dexMode to 'jar', ")
.append("otherwise,it will crash at some time");
announceWarningOrException(sb.toString());
}
}
final String oldXml = oldAndroidManifest.xml.trim();
final String newXml = newAndroidManifest.xml.trim();
final boolean isManifestChanged = !oldXml.equals(newXml);
if (!isManifestChanged) {
Logger.d("\nManifest has no changes, skip rest decodeworks.");
return false;
}
// check whether there is any new Android Component and get their names.
// so far only Activity increment can passchecking.
//不支持新增四大组件。
final Set<String> incActivities =getIncrementActivities(oldAndroidManifest.activities,newAndroidManifest.activities);
final Set<String> incServices =getIncrementServices(oldAndroidManifest.services, newAndroidManifest.services);
final Set<String> incReceivers =getIncrementReceivers(oldAndroidManifest.receivers,newAndroidManifest.receivers);
final Set<String> incProviders =getIncrementProviders(oldAndroidManifest.providers,newAndroidManifest.providers);
final boolean hasIncComponent = (!incActivities.isEmpty() ||!incServices.isEmpty()
|| !incProviders.isEmpty()|| !incReceivers.isEmpty());
if (!config.mSupportHotplugComponent && hasIncComponent) {
announceWarningOrException("manifest was changed, while hot plugcomponent support mode is disabled. "
+ "Such changeswill not take effect.");
}
// generate increment manifest.
if (hasIncComponent) {
final Document newXmlDoc =DocumentHelper.parseText(newAndroidManifest.xml);
final Document incXmlDoc = DocumentHelper.createDocument();
final Element newRootNode = newXmlDoc.getRootElement();
final String packageName =newRootNode.attributeValue(XML_NODEATTR_PACKAGE);
if (Utils.isNullOrNil(packageName)) {
throw newTinkerPatchException("Unable to find package name from manifest: " +newFile.getAbsolutePath());
}
final Element newAppNode =newRootNode.element(XML_NODENAME_APPLICATION);
final Element incAppNode = incXmlDoc.addElement(newAppNode.getQName());
copyAttributes(newAppNode, incAppNode);
if (!incActivities.isEmpty()) {
final List<Element>newActivityNodes = newAppNode.elements(XML_NODENAME_ACTIVITY);
final List<Element>incActivityNodes = getIncrementActivityNodes(packageName, newActivityNodes,incActivities);
for (Element node :incActivityNodes) {
incAppNode.add(node.detach());
}
}
if (!incServices.isEmpty()) {
final List<Element>newServiceNodes = newAppNode.elements(XML_NODENAME_SERVICE);
final List<Element>incServiceNodes = getIncrementServiceNodes(packageName, newServiceNodes,incServices);
for (Element node :incServiceNodes) {
incAppNode.add(node.detach());
}
}
if (!incReceivers.isEmpty()) {
final List<Element>newReceiverNodes = newAppNode.elements(XML_NODENAME_RECEIVER);
final List<Element>incReceiverNodes = getIncrementReceiverNodes(packageName, newReceiverNodes,incReceivers);
for (Element node :incReceiverNodes) {
incAppNode.add(node.detach());
}
}
if (!incProviders.isEmpty()) {
final List<Element>newProviderNodes = newAppNode.elements(XML_NODENAME_PROVIDER);
final List<Element>incProviderNodes = getIncrementProviderNodes(packageName, newProviderNodes,incProviders);
for (Element node :incProviderNodes) {
incAppNode.add(node.detach());
}
}
final File incXmlOutput = new File(config.mTempResultDir,TypedValue.INCCOMPONENT_META_FILE);
if (!incXmlOutput.exists()) {
incXmlOutput.getParentFile().mkdirs();
}
OutputStream os = null;
try {
os = newBufferedOutputStream(new FileOutputStream(incXmlOutput));
final XMLWriter docWriter =new XMLWriter(os);
docWriter.write(incXmlDoc);
docWriter.close();
} finally {
Utils.closeQuietly(os);
}
}
if (isManifestChanged && !hasIncComponent) {
Logger.d("\nManifest was changed, while there's no any newcomponents added."
+ " Make sure ifsuch changes were all you expected.\n");
}
}catch (ParseException e) {
e.printStackTrace();
throw new TinkerPatchException("Parse android manifesterror!");
}catch (DocumentException e) {
e.printStackTrace();
throw new TinkerPatchException("Parse android manifest by dom4jerror!");
}catch (IOException e) {
e.printStackTrace();
throw new TinkerPatchException("Failed to generate incrementmanifest.", e);
}
return false;
}
主要分析2：unzipApkFiles(oldFile, newFile)，
就是一个解压新旧apk的过程。可以学习到的是，针对apk的解压步骤。下面是解压apk的主要代码：
publicstatic void unZipAPk(String fileName, String filePath) throws IOException {
checkDirectory(filePath);//解压前，先判断destinationpath是否为空，为空的话就新建相关目录。
ZipFile zipFile = newZipFile(fileName);//apk其实也是一种zip压缩格式的文件，下面就是java代码如何解压zip格式的文件。
第一步：zipfile.entries()得到该zip文件中所有的文件enum。
Enumeration enumeration = zipFile.entries();
try {
第二步：遍历emum,类似于cursor遍历。
while (enumeration.hasMoreElements()) {
ZipEntry entry = (ZipEntry) enumeration.nextElement();
第三步：如果是目录的话，就需要新建一个目录。
if (entry.isDirectory()) {
new File(filePath,entry.getName()).mkdirs();
continue;
}
第四步：如果不是目录，那肯定就是文件，开始进行read和write过程。无论是inputstream还是outputstream都需要用bufferedstream来装饰下。
BufferedInputStream bis = newBufferedInputStream(zipFile.getInputStream(entry));
File file = new File(filePath + File.separator + entry.getName());
File parentFile = file.getParentFile();
if (parentFile != null && (!parentFile.exists())) {
parentFile.mkdirs();
}
FileOutputStream fos = null;
BufferedOutputStream bos = null;
try {
fos = newFileOutputStream(file);
bos = newBufferedOutputStream(fos, TypedValue.BUFFER_SIZE);
byte[] buf = newbyte[TypedValue.BUFFER_SIZE];
int len;
while ((len = bis.read(buf,0, TypedValue.BUFFER_SIZE)) != -1) {
fos.write(buf, 0, len);
}
} finally {
if (bos != null) {
bos.flush();
bos.close();
}
if (bis != null) {
bis.close();
}
}
}
}finally {
if (zipFile != null) {
zipFile.close();
}
}
}
主要分析3：Files.walkFileTree（Path,FileVisitor）
该方法是NIO中的方法，用于对一个目录进行遍历操作，里面的参数1是一个path，参数2是一个接口FileVisitor.该接口有四个抽象方法，具体使用方法可以查询百度。
public interface FileVisitor<T> {
//访问目录前
FileVisitResult preVisitDirectory(T var1, BasicFileAttributes var2)throws IOException;
//访问文件
FileVisitResult visitFile(T var1, BasicFileAttributes var2) throwsIOException;
//访问文件失败
FileVisitResult visitFileFailed(T var1, IOException var2) throwsIOException;
//访问目录后
FileVisitResult postVisitDirectory(T var1, IOException var2) throwsIOException;
}
在该方法中传入的是ApkFilesVisitor对象。
class ApkFilesVisitor extendsSimpleFileVisitor<Path> {
BaseDecoder dexDecoder;
BaseDecoder soDecoder;
BaseDecoder resDecoder;
Configuration config;
Path newApkPath;
Path oldApkPath;
ApkFilesVisitor(Configuration config, Path newPath, Path oldPath,BaseDecoder dex, BaseDecoder so, BaseDecoder resDecoder) {
this.config = config;
this.dexDecoder = dex;
this.soDecoder = so;
this.resDecoder = resDecoder;
this.newApkPath = newPath;
this.oldApkPath = oldPath;
}
@Override
public FileVisitResult visitFile(Path file, BasicFileAttributes attrs)throws IOException {
Path relativePath = newApkPath.relativize(file);//relative方法就是p1到p2的相对路径。这里拿到的是文件到XXXapk这个路径的相对路径。
Path oldPath = oldApkPath.resolve(relativePath);//如果relativepath是绝对路径，那么直接返回relativepath；否则，将relativepath添加到oldapkpath的后面。
File oldFile = null;
//is a new file?!
if (oldPath.toFile().exists()) {如果这个成立，意味着这是一个新增文件。
oldFile = oldPath.toFile();
}
String patternKey = relativePath.toString().replace("\\","/");
//判断当前访问的文件是不是classesN.dex文件，这个pattern是从tinker_config.xml中读出来的。
Xml文件中的注释
<!--what dexes in apk are expected to dealwith tinkerPatch-->
<!--it support * or ? pattern.-->
<patternvalue="classes*.dex"/>
<pattern value="assets/secondary-dex-?.jar"/>
if (Utils.checkFileInPattern(config.mDexFilePattern, patternKey)) {
//also treat duplicate file as unchanged
if (Utils.checkFileInPattern(config.mResFilePattern, patternKey)&& oldFile != null) {
resDuplicateFiles.add(oldFile);
}
try {
dexDecoder.patch(oldFile,file.toFile());//这个就是dexdecoder的实际生成dex patch的操作。
} catch (Exception e) {
// e.printStackTrace();
throw newRuntimeException(e);
}
return FileVisitResult.CONTINUE;
}
if (Utils.checkFileInPattern(config.mSoFilePattern, patternKey)) {
//also treat duplicate file as unchanged
if (Utils.checkFileInPattern(config.mResFilePattern, patternKey)&& oldFile != null) {
resDuplicateFiles.add(oldFile);
}
try {
soDecoder.patch(oldFile, file.toFile());//.so库生成patch
} catch (Exception e) {
// e.printStackTrace();
throw newRuntimeException(e);
}
return FileVisitResult.CONTINUE;
}
if (Utils.checkFileInPattern(config.mResFilePattern, patternKey)) {
try {
resDecoder.patch(oldFile,file.toFile());//resource文件生成patch
} catch (Exception e) {
// e.printStackTrace();
throw newRuntimeException(e);
}
return FileVisitResult.CONTINUE;
}
return FileVisitResult.CONTINUE;
}
}
DexDiffDecoder.java:
主要方法patch()
public boolean patch(final File oldFile, final File newFile) throwsIOException, TinkerPatchException {
final String dexName = getRelativeDexName(oldFile, newFile);
//first of all, we should check input files if excluded classes were modified.
Logger.d("Checkfor loader classes in dex: %s", dexName);
try {
主要分析1：将classes.dex文件转化成Dex对象，dex对象是根据class.dex文件格式定义的一种数据格式
excludedClassModifiedChecker.checkIfExcludedClassWasModifiedInNewDex(oldFile,newFile);
}catch (IOException e) {
throw new TinkerPatchException(e);
}catch (TinkerPatchException e) {
if (config.mIgnoreWarning) {
Logger.e("Warning:ignoreWarning is true, but we found %s",e.getMessage());
} else {
Logger.e("Warning:ignoreWarning is false, but we found %s",e.getMessage());
throw e;
}
}catch (Exception e) {
e.printStackTrace();
}
//If corresponding new dex was completely deleted, just return false.
//don't process 0 length dex
if(newFile == null || !newFile.exists() || newFile.length() == 0) {
return false;
}
File dexDiffOut = getOutputPath(newFile).toFile();
final String newMd5 = getRawOrWrappedDexMD5(newFile);
//new add file
if(oldFile == null || !oldFile.exists() || oldFile.length() == 0) {
hasDexChanged = true;
//新增的classes.dex文件集合
copyNewDexAndLogToDexMeta(newFile,newMd5, dexDiffOut);
return true;
}
//获取文件的MD5值。可以学到的是求一个文件的md5的方法。
final String oldMd5 = getRawOrWrappedDexMD5(oldFile);
if((oldMd5 != null && !oldMd5.equals(newMd5)) || (oldMd5 == null&& newMd5 != null)) {
hasDexChanged = true;
if (oldMd5 != null) {
修改了的dex文件集合
collectAddedOrDeletedClasses(oldFile, newFile);
}
}
RelatedInfo relatedInfo = new RelatedInfo();
relatedInfo.oldMd5 = oldMd5;
relatedInfo.newMd5 = newMd5;
//把相对应的oldfile和newfile做成一个entry
//collect current old dex file and corresponding new dex file for furtherprocessing.
oldAndNewDexFilePairList.add(new AbstractMap.SimpleEntry<>(oldFile,newFile));
dexNameToRelatedInfoMap.put(dexName, relatedInfo);
return ;
}
excludedClassModifiedChecker.checkIfExcludedClassWasModifiedInNewDex(oldFile,newFile);
public void checkIfExcludedClassWasModifiedInNewDex(FileoldFile, File newFile) throws IOException, TinkerPatchException {
if(oldFile == null && newFile == null) {
throw new TinkerPatchException("both oldFile and newFile arenull.");
}
oldDex = (oldFile !=null ? new Dex(oldFile) : null);
newDex = (newFile != null ? new Dex(newFile) : null);
int stmCode = STMCODE_START;
while (stmCode != STMCODE_END) {
switch (stmCode) {
/**
* Check rule:
* Loader classes must only appear in primary dex and each of them inprimary old dex should keep
* completely consistent in new primary dex.
*
* An error is announced when any of these conditions below is fit:
* 1. Primary old dex is missing.
* 2. Primary new dex is missing.
* 3. There are not any loader classes in primary old dex.
* 4. There are some new loader classes added in new primary dex.
* 5. Loader classes in old primary dex are modified, deleted in newprimary dex.
* 6. Loader classes are found in secondary old dexes.
* 7. Loader classes are found in secondary new dexes.
*/
case STMCODE_START: {
//主dex中的类是大部分不能做任何修改的，包括添加新类，删除已有类。如果对类做了修改，但是该类在ignorechangewarning的名单中，那么是允许的，否则不允许。还有一种错误情况是，在tinker_xml中用loader标签的dex文件，被放在了非主dex中，这样也会报错。
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);//就是对new old 主dex包进行比较。
deletedClassInfos =dexCmptor.getDeletedClassInfos();//删除的class
addedClassInfos =dexCmptor.getAddedClassInfos();//新增的class
changedClassInfosMap = new HashMap<>(dexCmptor.getChangedClassDescToInfosMap());//做了更改的class
// All loaderclasses are in new dex, while none of them in old one.
if(deletedClassInfos.isEmpty() && changedClassInfosMap.isEmpty()&& !addedClassInfos.isEmpty()) {
stmCode =STMCODE_ERROR_LOADER_CLASS_NOT_IN_PRIMARY_OLD_DEX;
} else {
if(deletedClassInfos.isEmpty() && addedClassInfos.isEmpty()) {
// classdescriptor is completely matches, see if any contents changes.
ArrayList<String> removeClasses = new ArrayList<>();
for (Stringclassname : changedClassInfosMap.keySet()) {
if(Utils.checkFileInPattern(ignoreChangeWarning, classname)) {
Logger.e("loader class pattern: " + classname + " haschanged, but it match ignore change pattern, just ignore!");
removeClasses.add(classname);
}
}
changedClassInfosMap.keySet().removeAll(removeClasses);
if(changedClassInfosMap.isEmpty()) {
stmCode= STMCODE_END;
} else {
stmCode= STMCODE_ERROR_LOADER_CLASS_CHANGED;
}
} else {
stmCode =STMCODE_ERROR_LOADER_CLASS_IN_PRIMARY_DEX_MISMATCH;
}
}
}
} else {
Set<Pattern>patternsOfClassDescToCheck = new HashSet<>();
for (String patternStr: config.mDexLoaderPattern) {
patternsOfClassDescToCheck.add(
Pattern.compile(
PatternUtils.dotClassNamePatternToDescriptorRegEx(patternStr)
)
);
}
if (oldDex != null) {
oldClassesDescToCheck.clear();
//这里就是判断是否存在使用loader标注的class被放在了非主dex中。
for (ClassDefclassDef : 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 (ClassDefclassDef : 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;
}
break;
}
case STMCODE_ERROR_PRIMARY_OLD_DEX_IS_MISSING: {
throw newTinkerPatchException("old primary dex is missing.");
}
case STMCODE_ERROR_PRIMARY_NEW_DEX_IS_MISSING: {
throw newTinkerPatchException("new primary dex is missing.");
}
case STMCODE_ERROR_LOADER_CLASS_NOT_IN_PRIMARY_OLD_DEX: {
throw newTinkerPatchException("all loader classes don't appear in old primarydex.");
}
case STMCODE_ERROR_LOADER_CLASS_IN_PRIMARY_DEX_MISMATCH: {
throw newTinkerPatchException(
"loader classes inold primary dex are mismatched to those in new primary dex, \n"
+ "if deletedclasses is not empty, check if your dex division strategy is fine. \n"
+ "addedclasses: " + Utils.collectionToString(addedClassInfos) + "\n"
+ "deletedclasses: " + Utils.collectionToString(deletedClassInfos)
);
}
case STMCODE_ERROR_LOADER_CLASS_FOUND_IN_SECONDARY_OLD_DEX: {
throw newTinkerPatchException("loader classes are found in old secondary dex. Foundclasses: " + Utils.collectionToString(oldClassesDescToCheck));
}
case STMCODE_ERROR_LOADER_CLASS_FOUND_IN_SECONDARY_NEW_DEX: {
throw newTinkerPatchException("loader classes are found in new secondary dex. Foundclasses: " + Utils.collectionToString(newClassesDescToCheck));
}
case STMCODE_ERROR_LOADER_CLASS_CHANGED: {
String msg =
"some loader classhas been changed in new dex."
+ " Such thesechanges will not take effect!!"
+ " relatedclasses: "
+Utils.collectionToString(changedClassInfosMap.keySet());
throw newTinkerPatchException(msg);
}
default: {
Logger.e("internal-error: unexpected stmCode.");
stmCode = STMCODE_END;
break;
}
}
}
}
Dex.java
public Dex(File file) throws IOException {
if(file == null) {
throw new IllegalArgumentException("file is null.");
}
if(FileUtils.hasArchiveSuffix(file.getName())) {
ZipFile zipFile = null;
try {
zipFile = new ZipFile(file);
这种情况是指对dex文件进行了jar打包操作。
ZipEntry entry = zipFile.getEntry(DexFormat.DEX_IN_JAR_NAME);
if (entry != null) {
InputStream inputStream =null;
try {
inputStream =zipFile.getInputStream(entry);
loadFrom(inputStream,(int) entry.getSize());
} finally {
if (inputStream !=null) {
inputStream.close();
}
}
} else {
throw newDexException("Expected " + DexFormat.DEX_IN_JAR_NAME + " in" + file);
}
} finally {
if (zipFile != null) {
try {
zipFile.close();
} catch (Exception e) {
// ignored.
}
}
}
这种就是未对.dex文件进行jar打包操作的。
}else if (file.getName().endsWith(".dex")) {
InputStream in = null;
try {
in = new BufferedInputStream(new FileInputStream(file));
loadFrom(in, (int) file.length());
} catch (Exception e) {
throw new DexException(e);
} finally {
if (in != null) {
try {
in.close();
} catch (Exception e) {
// ignored.
}
}
}
} else {
throw new DexException("unknown output extension: " + file);
}
}
loadFrom(in, (int)file.length());
这个就是将dex文件以字节流的方式读入内存中。这个需要理解dex文件解析内容，不做深究。
private void loadFrom(InputStream in, intinitSize) throws IOException {
byte[] rawData = FileUtils.readStream(in,initSize);
this.data = ByteBuffer.wrap(rawData);
this.data.order(ByteOrder.LITTLE_ENDIAN);//大小端问题，dex文件中都是以小端方式放置数据的。
this.tableOfContents.readFrom(this);
}
getRawOrWrappedDexMD5(oldFile)
最终的实现获取md5的代码：
/**
* Getthe md5 for inputStream.
*This method cost less memory. It read bufLen bytes from the FileInputStreamonce.
*
*@param is
*@param bufLen bytes number read from the stream once.
* The less bufLen isthe more times getMD5() method takes. Also the less bufLen is the less memorycost.
*/
publicstatic String getMD5(final InputStream is, final int bufLen) {
if(is == null || bufLen <= 0) {
return null;
}
try {
MessageDigest md = MessageDigest.getInstance("MD5");
StringBuilder md5Str = new StringBuilder(32);
byte[] buf = new byte[bufLen];
int readCount = 0;
while ((readCount = is.read(buf)) != -1) {
md.update(buf, 0, readCount);
}
byte[] hashValue = md.digest();
for (int i = 0; i < hashValue.length; i++) {
md5Str.append(Integer.toString((hashValue[i] & 0xff) + 0x100,16).substring(1));
}
return md5Str.toString();
}catch (Exception e) {
return null;
}
}
soDecoder.patch(oldFile,file.toFile());//.so库生成patch
Sodecoder实际类型是BsDiffDecoder，下面看下它的patch()方法
@Override
publicboolean patch(File oldFile, File newFile) throws IOException,TinkerPatchException {
//first of all, we should check input files
if(newFile == null || !newFile.exists()) {
return false;
}
//new add file
String newMd5 = MD5.getMD5(newFile);
File bsDiffFile = getOutputPath(newFile).toFile();
if(oldFile == null || !oldFile.exists()) {
FileOperation.copyFileUsingStream(newFile, bsDiffFile);
writeLogFiles(newFile, null, null, newMd5);
return true;
}
//both file length is 0
if(oldFile.length() == 0 && newFile.length() == 0) {
return false;
}
if(oldFile.length() == 0 || newFile.length() == 0) {
FileOperation.copyFileUsingStream(newFile, bsDiffFile);
writeLogFiles(newFile, null, null, newMd5);
return true;
}
//new add file
String oldMd5 = MD5.getMD5(oldFile);
if(oldMd5.equals(newMd5)) {
return false;
}
if(!bsDiffFile.getParentFile().exists()) {
bsDiffFile.getParentFile().mkdirs();
}
//直接使用java版的bsdiff算法，生成so库的patch文件
BSDiff.bsdiff(oldFile, newFile, bsDiffFile);
//如果文件太大，则直接新增一个file，否则还是按照patch文件制作。
if(Utils.checkBsDiffFileSize(bsDiffFile, newFile)) {
writeLogFiles(newFile, oldFile, bsDiffFile, newMd5);
}else {
FileOperation.copyFileUsingStream(newFile, bsDiffFile);
writeLogFiles(newFile, null, null, newMd5);
}
return true;
}
resDecoder.patch(oldFile,file.toFile());//resource文件生成patch
@Override
publicboolean patch(File oldFile, File newFile) throws IOException,TinkerPatchException {
String name = getRelativePathStringToNewFile(newFile);
//actually, it won't go below
if(newFile == null || !newFile.exists()) {
String relativeStringByOldDir =getRelativePathStringToOldFile(oldFile);
if (Utils.checkFileInPattern(config.mResIgnoreChangePattern,relativeStringByOldDir)) {
Logger.e("found delete resource: " + relativeStringByOldDir +" ,but it match ignore change pattern, just ignore!");
return false;
}
deletedSet.add(relativeStringByOldDir);
writeResLog(newFile, oldFile, TypedValue.DEL);
return true;
}
FileoutputFile = getOutputPath(newFile).toFile();
if(oldFile == null || !oldFile.exists()) {
//该文件刚好在ignorechange的pattern匹配格式中，so 忽略它。
if (Utils.checkFileInPattern(config.mResIgnoreChangePattern, name)) {
Logger.e("found add resource: " + name + " ,but it matchignore change pattern, just ignore!");
return false;
}
FileOperation.copyFileUsingStream(newFile, outputFile);
addedSet.add(name);
writeResLog(newFile, oldFile, TypedValue.ADD);
return true;
}
//both file length is 0
if(oldFile.length() == 0 && newFile.length() == 0) {
return false;
}
//new add file
StringnewMd5 = MD5.getMD5(newFile);
String oldMd5 = MD5.getMD5(oldFile);
//oldFile or newFile may be 0b length
if(oldMd5 != null && oldMd5.equals(newMd5)) {
return false;
}
//该文件刚好在ignorechange的pattern匹配格式中，so 忽略它。
if(Utils.checkFileInPattern(config.mResIgnoreChangePattern, name)) {
Logger.d("found modify resource: " + name + ", but itmatch ignore change pattern, just ignore!");
return false;
}
//如果该文件是manifest文件，也需要忽略，因为manifest有专门的decoder.
if(name.equals(TypedValue.RES_MANIFEST)) {
Logger.d("found modify resource: " + name + ", but it isAndroidManifest.xml, just ignore!");
return false;
}
//arsc文件
if(name.equals(TypedValue.RES_ARSC)) {
if (AndroidParser.resourceTableLogicalChange(config)) {//这里面又涉及到arsc文件格式的解析，忽略。
Logger.d("found modify resource: " + name + ", but it islogically the same as original new resources.arsc, just ignore!");
return false;
}
}
//处理被修改的文件。
dealWithModifyFile(name, newMd5, oldFile, newFile, outputFile);
return true;
}
dexPatchDecoder.onAllPatchesEnd()
该方法就是根据前面比对的new apk和old apk结果，把新增的或者修改的.class文件（就是dex文件描述的class文件，对应的数据对象的名称是Dexclassinfo），写到一个changed_classes.dex中，这里面涉及到dex文件格式，dex文件写入，还有虚拟机指令，非常深入，下面只简单地过一下流程。
@Override
publicvoid onAllPatchesEnd() throws Exception {
if(!hasDexChanged) {
Logger.d("No dexes were changed, nothing needs to be donenext.");
return;
}
if(config.mIsProtectedApp) {
generateChangedClassesDexFile();
}else {
generatePatchInfoFile();//主要分析这个方法
}
addTestDex();
}
generatePatchInfoFile();
@SuppressWarnings("NewApi")
private void generatePatchInfoFile() throws IOException {
generatePatchedDexInfoFile();
//generateSmallPatchedDexInfoFile is blocked by issue we found in ART environment
// which indicates that if inline optimizationis done on patched class, some error
//such as crash, ClassCastException, mistaken string fetching, etc. would happen.
//
//Instead, we will log all classN dexes as 'copy directly' in dex-meta, so that
//tinker patch applying procedure will copy them out and load them in ARTenvironment.
//generateSmallPatchedDexInfoFile();
logDexesToDexMeta();
checkCrossDexMovingClasses();
}
generatePatchedDexInfoFile();
@SuppressWarnings("NewApi")
private void generatePatchedDexInfoFile() {
//Generate dex diff out and full patched dex if a pair of dex is different.
这个oldAndNewDexFilePairList就是patch()方法中得到的有变化的classesN.dex新旧文件。
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 ofthis dex should be kept in small patch.
relatedInfo.newOrFullPatchedFile = newFile;
relatedInfo.newOrFullPatchedMd5 = relatedInfo.newMd5;
}
}
}
diffDexPairAndFillRelatedInfo(oldFile,newFile, relatedInfo);
private void diffDexPairAndFillRelatedInfo(FileoldDexFile, File newDexFile, RelatedInfo relatedInfo) {
File tempFullPatchDexPath = new File(config.mOutFolder + File.separator+ TypedValue.DEX_TEMP_PATCH_DIR);
final String dexName = getRelativeDexName(oldDexFile, newDexFile);
File dexDiffOut = getOutputPath(newDexFile).toFile();
ensureDirectoryExist(dexDiffOut.getParentFile());
try {
DexPatchGenerator dexPatchGen = new DexPatchGenerator(oldDexFile,newDexFile);
dexPatchGen.setAdditionalRemovingClassPatterns(config.mDexLoaderPattern);
logWriter.writeLineToInfoFile(
String.format(
"Start diffbetween [%s] as old and [%s] as new:",
getRelativeStringBy(oldDexFile, config.mTempUnzipOldDir),
getRelativeStringBy(newDexFile, config.mTempUnzipNewDir)
)
);
dexPatchGen.executeAndSaveTo(dexDiffOut);最终会调用DexPatchGenerator.java的executeAndSaveTo（）方法，下面重点分析该方法。
}catch (Exception e) {
throw new TinkerPatchException(e);
}
if(!dexDiffOut.exists()) {
throw new TinkerPatchException("can not find the diff file:" +dexDiffOut.getAbsolutePath());
}
relatedInfo.dexDiffFile = dexDiffOut;
relatedInfo.dexDiffMd5 = MD5.getMD5(dexDiffOut);
Logger.d("\nGen %s patch file:%s, size:%d, md5:%s", dexName,relatedInfo.dexDiffFile.getAbsolutePath(), relatedInfo.dexDiffFile.length(),relatedInfo.dexDiffMd5);
File tempFullPatchedDexFile = new File(tempFullPatchDexPath, dexName);
if(!tempFullPatchedDexFile.exists()) {
ensureDirectoryExist(tempFullPatchedDexFile.getParentFile());
}
try {
new DexPatchApplier(oldDexFile,dexDiffOut).executeAndSaveTo(tempFullPatchedDexFile);
Logger.d(
String.format("Verifyingif patched new dex is logically the same as original new dex: %s ...",getRelativeStringBy(newDexFile, config.mTempUnzipNewDir))
);
Dex origNewDex = new Dex(newDexFile);
Dex patchedNewDex = new Dex(tempFullPatchedDexFile);
checkDexChange(origNewDex, patchedNewDex);
relatedInfo.newOrFullPatchedFile = tempFullPatchedDexFile;
relatedInfo.newOrFullPatchedMd5 = MD5.getMD5(tempFullPatchedDexFile);
}catch (Exception e) {
e.printStackTrace();
throw new TinkerPatchException(
"Failed to generatetemporary patched dex, which makes MD5 generating procedure of new dex failed,either.", e
);
}
if(!tempFullPatchedDexFile.exists()) {
throw new TinkerPatchException("can not find the temporary fullpatched dex file:" + tempFullPatchedDexFile.getAbsolutePath());
}
Logger.d("\nGen %s for dalvik full dex file:%s, size:%d,md5:%s", dexName, tempFullPatchedDexFile.getAbsolutePath(),tempFullPatchedDexFile.length(), relatedInfo.newOrFullPatchedMd5);
}
executeAndSaveTo(OutputStream out):
public void executeAndSaveTo(OutputStream out)throws IOException {
//Firstly, collect information of items we want to remove additionally
//in new dex and set them to corresponding diff algorithm implementations.
// 哪些文件的变化应该忽略，不应该添加到patch中。
Pattern[] classNamePatterns = new Pattern[this.additionalRemovingClassPatternSet.size()];
int classNamePatternCount = 0;
for (String regExStr : this.additionalRemovingClassPatternSet) {
classNamePatterns[classNamePatternCount++] = Pattern.compile(regExStr);
}
List<Integer> typeIdOfClassDefsToRemove = newArrayList<>(classNamePatternCount);
List<Integer> offsetOfClassDatasToRemove = newArrayList<>(classNamePatternCount);
for (ClassDef classDef : this.newDex.classDefs()) {
//拿到dex文件中的所有类定义，判断是否在上面得到的忽略list中
String typeName = this.newDex.typeNames().get(classDef.typeIndex);
for (Pattern pattern : classNamePatterns) {
if (pattern.matcher(typeName).matches()) {
typeIdOfClassDefsToRemove.add(classDef.typeIndex);
offsetOfClassDatasToRemove.add(classDef.classDataOffset);
break;
}
}
}
((ClassDefSectionDiffAlgorithm) this.classDefSectionDiffAlg)
.setTypeIdOfClassDefsToRemove(typeIdOfClassDefsToRemove);
((ClassDataSectionDiffAlgorithm) this.classDataSectionDiffAlg)
.setOffsetOfClassDatasToRemove(offsetOfClassDatasToRemove);
//下面开始就是根据dex数据格式，比较新的dex文件和旧的dex文件，根据区别生成dex patch，算法复杂，需要对dex文件格式非常精通。
//Then, run diff algorithms according to sections' dependencies.
//Use size calculated by algorithms above or from dex file definition to
//calculate sections' offset and patched dex size.
//Calculate header and id sections size, so that we can work out
//the base offset of typeLists Section.
int patchedheaderSize = SizeOf.HEADER_ITEM;
int patchedStringIdsSize = newDex.getTableOfContents().stringIds.size *SizeOf.STRING_ID_ITEM;
int patchedTypeIdsSize = newDex.getTableOfContents().typeIds.size *SizeOf.TYPE_ID_ITEM;
//Although simulatePatchOperation can calculate this value, since protoIdssection
//depends on typeLists section, we can't run protoIds Section'ssimulatePatchOperation
//method so far. Instead we calculate protoIds section's size using informationin newDex
//directly.
int patchedProtoIdsSize = newDex.getTableOfContents().protoIds.size *SizeOf.PROTO_ID_ITEM;
int patchedFieldIdsSize = newDex.getTableOfContents().fieldIds.size *SizeOf.MEMBER_ID_ITEM;
int patchedMethodIdsSize = newDex.getTableOfContents().methodIds.size *SizeOf.MEMBER_ID_ITEM;
int patchedClassDefsSize = newDex.getTableOfContents().classDefs.size *SizeOf.CLASS_DEF_ITEM;
int patchedIdSectionSize =
patchedStringIdsSize
+ patchedTypeIdsSize
+ patchedProtoIdsSize
+ patchedFieldIdsSize
+ patchedMethodIdsSize
+ patchedClassDefsSize;
this.patchedHeaderOffset = 0;
//The diff works on each sections obey such procedure:
// 1. Execute diff algorithms tocalculate indices of items we need to add, del and replace.
// 2. Execute patch algorithmsimulation to calculate indices and offsets mappings that is
// necessary to next section'sdiff works.
//Immediately do the patch simulation so that we can know:
// 1. Indices and offsets mappingbetween old dex and patched dex.
// 2. Indices and offsets mappingbetween new dex and patched dex.
//These information will be used to do next diff works.
this.patchedStringIdsOffset = patchedHeaderOffset + patchedheaderSize;
if(this.oldDex.getTableOfContents().stringIds.isElementFourByteAligned) {
this.patchedStringIdsOffset
= SizeOf.roundToTimesOfFour(this.patchedStringIdsOffset);
}
this.stringDataSectionDiffAlg.execute();
this.patchedStringDataItemsOffset = patchedheaderSize +patchedIdSectionSize;
if(this.oldDex.getTableOfContents().stringDatas.isElementFourByteAligned) {
this.patchedStringDataItemsOffset
=SizeOf.roundToTimesOfFour(this.patchedStringDataItemsOffset);
}
this.stringDataSectionDiffAlg.simulatePatchOperation(this.patchedStringDataItemsOffset);
this.typeIdSectionDiffAlg.execute();
this.patchedTypeIdsOffset = this.patchedStringIdsOffset +patchedStringIdsSize;
if(this.oldDex.getTableOfContents().typeIds.isElementFourByteAligned) {
this.patchedTypeIdsOffset
=SizeOf.roundToTimesOfFour(this.patchedTypeIdsOffset);
}
this.typeIdSectionDiffAlg.simulatePatchOperation(this.patchedTypeIdsOffset);
this.typeListSectionDiffAlg.execute();
this.patchedTypeListsOffset
= patchedheaderSize
+ patchedIdSectionSize
+ this.stringDataSectionDiffAlg.getPatchedSectionSize();
if(this.oldDex.getTableOfContents().typeLists.isElementFourByteAligned) {
this.patchedTypeListsOffset
=SizeOf.roundToTimesOfFour(this.patchedTypeListsOffset);
}
this.typeListSectionDiffAlg.simulatePatchOperation(this.patchedTypeListsOffset);
this.protoIdSectionDiffAlg.execute();
this.patchedProtoIdsOffset = this.patchedTypeIdsOffset +patchedTypeIdsSize;
if(this.oldDex.getTableOfContents().protoIds.isElementFourByteAligned) {
this.patchedProtoIdsOffset = SizeOf.roundToTimesOfFour(this.patchedProtoIdsOffset);
}
this.protoIdSectionDiffAlg.simulatePatchOperation(this.patchedProtoIdsOffset);
this.fieldIdSectionDiffAlg.execute();
this.patchedFieldIdsOffset = this.patchedProtoIdsOffset +patchedProtoIdsSize;
if(this.oldDex.getTableOfContents().fieldIds.isElementFourByteAligned) {
this.patchedFieldIdsOffset =SizeOf.roundToTimesOfFour(this.patchedFieldIdsOffset);
}
this.fieldIdSectionDiffAlg.simulatePatchOperation(this.patchedFieldIdsOffset);
this.methodIdSectionDiffAlg.execute();
this.patchedMethodIdsOffset = this.patchedFieldIdsOffset +patchedFieldIdsSize;
if(this.oldDex.getTableOfContents().methodIds.isElementFourByteAligned) {
this.patchedMethodIdsOffset =SizeOf.roundToTimesOfFour(this.patchedMethodIdsOffset);
}
this.methodIdSectionDiffAlg.simulatePatchOperation(this.patchedMethodIdsOffset);
this.annotationSectionDiffAlg.execute();
this.patchedAnnotationItemsOffset
= this.patchedTypeListsOffset
+ this.typeListSectionDiffAlg.getPatchedSectionSize();
if(this.oldDex.getTableOfContents().annotations.isElementFourByteAligned) {
this.patchedAnnotationItemsOffset
=SizeOf.roundToTimesOfFour(this.patchedAnnotationItemsOffset);
}
this.annotationSectionDiffAlg.simulatePatchOperation(this.patchedAnnotationItemsOffset);
this.annotationSetSectionDiffAlg.execute();
this.patchedAnnotationSetItemsOffset
= this.patchedAnnotationItemsOffset
+ this.annotationSectionDiffAlg.getPatchedSectionSize();
if(this.oldDex.getTableOfContents().annotationSets.isElementFourByteAligned) {
this.patchedAnnotationSetItemsOffset
=SizeOf.roundToTimesOfFour(this.patchedAnnotationSetItemsOffset);
}
this.annotationSetSectionDiffAlg.simulatePatchOperation(
this.patchedAnnotationSetItemsOffset
);
this.annotationSetRefListSectionDiffAlg.execute();
this.patchedAnnotationSetRefListItemsOffset
= this.patchedAnnotationSetItemsOffset
+ this.annotationSetSectionDiffAlg.getPatchedSectionSize();
if(this.oldDex.getTableOfContents().annotationSetRefLists.isElementFourByteAligned){
this.patchedAnnotationSetRefListItemsOffset
=SizeOf.roundToTimesOfFour(this.patchedAnnotationSetRefListItemsOffset);
}
this.annotationSetRefListSectionDiffAlg.simulatePatchOperation(
this.patchedAnnotationSetRefListItemsOffset
);
this.annotationsDirectorySectionDiffAlg.execute();
this.patchedAnnotationsDirectoryItemsOffset
= this.patchedAnnotationSetRefListItemsOffset
+ this.annotationSetRefListSectionDiffAlg.getPatchedSectionSize();
if(this.oldDex.getTableOfContents().annotationsDirectories.isElementFourByteAligned){
this.patchedAnnotationsDirectoryItemsOffset
=SizeOf.roundToTimesOfFour(this.patchedAnnotationsDirectoryItemsOffset);
}
this.annotationsDirectorySectionDiffAlg.simulatePatchOperation(
this.patchedAnnotationsDirectoryItemsOffset
);
this.debugInfoSectionDiffAlg.execute();
this.patchedDebugInfoItemsOffset
= this.patchedAnnotationsDirectoryItemsOffset
+ this.annotationsDirectorySectionDiffAlg.getPatchedSectionSize();
if(this.oldDex.getTableOfContents().debugInfos.isElementFourByteAligned) {
this.patchedDebugInfoItemsOffset
=SizeOf.roundToTimesOfFour(this.patchedDebugInfoItemsOffset);
}
this.debugInfoSectionDiffAlg.simulatePatchOperation(this.patchedDebugInfoItemsOffset);
this.codeSectionDiffAlg.execute();
this.patchedCodeItemsOffset
= this.patchedDebugInfoItemsOffset
+ this.debugInfoSectionDiffAlg.getPatchedSectionSize();
if(this.oldDex.getTableOfContents().codes.isElementFourByteAligned) {
this.patchedCodeItemsOffset =SizeOf.roundToTimesOfFour(this.patchedCodeItemsOffset);
}
this.codeSectionDiffAlg.simulatePatchOperation(this.patchedCodeItemsOffset);
this.classDataSectionDiffAlg.execute();
this.patchedClassDataItemsOffset
= this.patchedCodeItemsOffset
+ this.codeSectionDiffAlg.getPatchedSectionSize();
if(this.oldDex.getTableOfContents().classDatas.isElementFourByteAligned) {
this.patchedClassDataItemsOffset
=SizeOf.roundToTimesOfFour(this.patchedClassDataItemsOffset);
}
this.classDataSectionDiffAlg.simulatePatchOperation(this.patchedClassDataItemsOffset);
this.encodedArraySectionDiffAlg.execute();
this.patchedEncodedArrayItemsOffset
= this.patchedClassDataItemsOffset
+ this.classDataSectionDiffAlg.getPatchedSectionSize();
if(this.oldDex.getTableOfContents().encodedArrays.isElementFourByteAligned) {
this.patchedEncodedArrayItemsOffset
=SizeOf.roundToTimesOfFour(this.patchedEncodedArrayItemsOffset);
}
this.encodedArraySectionDiffAlg.simulatePatchOperation(this.patchedEncodedArrayItemsOffset);
this.classDefSectionDiffAlg.execute();
this.patchedClassDefsOffset = this.patchedMethodIdsOffset +patchedMethodIdsSize;
if(this.oldDex.getTableOfContents().classDefs.isElementFourByteAligned) {
this.patchedClassDefsOffset =SizeOf.roundToTimesOfFour(this.patchedClassDefsOffset);
}
//Calculate any values we still know nothing about them.
this.patchedMapListOffset
= this.patchedEncodedArrayItemsOffset
+ this.encodedArraySectionDiffAlg.getPatchedSectionSize();
if(this.oldDex.getTableOfContents().mapList.isElementFourByteAligned) {
this.patchedMapListOffset =SizeOf.roundToTimesOfFour(this.patchedMapListOffset);
}
int patchedMapListSize = newDex.getTableOfContents().mapList.byteCount;
this.patchedDexSize
= this.patchedMapListOffset
+ patchedMapListSize;
//Finally, write results to patch file.
writeResultToStream(out);
}
云里雾里总算粗略地过了一遍，其实还有resdecoder.onpatchEnd()没有分析，实在头大，等把patch合成过程分析完后，再回过头来看看patch的生成过程，或许会好一些。
上面就是patch的生成过程，接下来需要分析patch的合成过程。。。。。。
客户端用法，就不详述了，需要重写application，使用tinker提供的applicationlike模板，好吧这又涉及到了一个知识点，gradle模板动态生成代码，有时间再看。。。。然后在合适的时机调用启动合成patch的方法：
参数就传patch文件所在路径
TinkerInstaller.onReceiveUpgradePatch(getApplicationContext(),
Environment.getExternalStorageDirectory().getAbsolutePath() +"/patch_signed_7zip.apk");
初始化一些基本参数：
public Builder(Context context) {
if (context == null) {
throw new TinkerRuntimeException("Context must not be null.");
}
this.context = context;
this.mainProcess = TinkerServiceInternals.isInMainProcess(context);
this.patchProcess = TinkerServiceInternals.isInTinkerPatchServiceProcess(context);
this.patchDirectory = SharePatchFileUtil.getPatchDirectory(context);
if (this.patchDirectory == null) {
TinkerLog.e(TAG, "patchDirectory is null!");
return;
}
this.patchInfoFile =SharePatchFileUtil.getPatchInfoFile(patchDirectory.getAbsolutePath());
this.patchInfoLockFile =SharePatchFileUtil.getPatchInfoLockFile(patchDirectory.getAbsolutePath());
TinkerLog.w(TAG, "tinker patch directory: %s",patchDirectory);
}
接下来调用DefaultPatchListener.java的onPatchReceived(Stringpath)：
@Override
publicint onPatchReceived(String path) {
需要分析1：
int returnCode = patchCheck(path);
if(returnCode == ShareConstants.ERROR_PATCH_OK) {
需要分析2：
TinkerPatchService.runPatchService(context, path);
}else {
Tinker.with(context).getLoadReporter().onLoadPatchListenerReceiveFail(newFile(path), returnCode);
}
return returnCode;
}
patchCheck():主要做配置检查。代码略。
最终的调用会在UpgradePatch.java的tryPatch()
@Override
publicboolean tryPatch(Context context, String tempPatchPath, PatchResultpatchResult) {
Tinker manager = Tinker.with(context);
finalFile patchFile = new File(tempPatchPath);
if(!manager.isTinkerEnabled() ||!ShareTinkerInternals.isTinkerEnableWithSharedPreferences(context)) {
TinkerLog.e(TAG, "UpgradePatch tryPatch:patch is disabled, justreturn");
return false;
}
if(!SharePatchFileUtil.isLegalFile(patchFile)) {
TinkerLog.e(TAG, "UpgradePatch tryPatch:patch file is not found,just return");
return false;
}
签名检查，可以学习下
//check the signature, we should create a new checker
ShareSecurityChecksignatureCheck = new ShareSecurityCheck(context);
//签名验证,还必须有tinkerId，否则会直接报错。
int returnCode = ShareTinkerInternals.checkTinkerPackage(context,manager.getTinkerFlags(), patchFile, signatureCheck);
if(returnCode != ShareConstants.ERROR_PACKAGE_CHECK_OK) {
TinkerLog.e(TAG, "UpgradePatch tryPatch:onPatchPackageCheckFail");
manager.getPatchReporter().onPatchPackageCheckFail(patchFile,returnCode);
return false;
}
String patchMd5 = SharePatchFileUtil.getMD5(patchFile);
if(patchMd5 == null) {
TinkerLog.e(TAG, "UpgradePatch tryPatch:patch md5 is null, justreturn");
return false;
}
//use md5 as version
patchResult.patchVersion = patchMd5;
TinkerLog.i(TAG, "UpgradePatch tryPatch:patchMd5:%s",patchMd5);
//check ok, we can real recover a newpatch
final String patchDirectory =manager.getPatchDirectory().getAbsolutePath();
//file
File patchInfoLockFile =SharePatchFileUtil.getPatchInfoLockFile(patchDirectory);
File patchInfoFile =SharePatchFileUtil.getPatchInfoFile(patchDirectory);
SharePatchInfo oldInfo =SharePatchInfo.readAndCheckPropertyWithLock(patchInfoFile, patchInfoLockFile);
//it is a new patch, so we should not find a exist
SharePatchInfo newInfo;
//already have patch
if(oldInfo != null) {
if (oldInfo.oldVersion == null || oldInfo.newVersion == null ||oldInfo.oatDir == null) {
TinkerLog.e(TAG, "UpgradePatch tryPatch:onPatchInfoCorrupted");
manager.getPatchReporter().onPatchInfoCorrupted(patchFile,oldInfo.oldVersion, oldInfo.newVersion);
return false;
}
if (!SharePatchFileUtil.checkIfMd5Valid(patchMd5)) {
TinkerLog.e(TAG,"UpgradePatch tryPatch:onPatchVersionCheckFail md5 %s is valid",patchMd5);
manager.getPatchReporter().onPatchVersionCheckFail(patchFile, oldInfo,patchMd5);
return false;
}
// if it is interpret now, use changing flag to wait main process
final String finalOatDir =oldInfo.oatDir.equals(ShareConstants.INTERPRET_DEX_OPTIMIZE_PATH)
? ShareConstants.CHANING_DEX_OPTIMIZE_PATH : oldInfo.oatDir;
newInfo = new SharePatchInfo(oldInfo.oldVersion, patchMd5,Build.FINGERPRINT, finalOatDir);
}else {
newInfo = new SharePatchInfo("", patchMd5, Build.FINGERPRINT,ShareConstants.DEFAULT_DEX_OPTIMIZE_PATH);
}
//it is a new patch, we first delete if thereis any files
//don't delete dir for faster retry
// SharePatchFileUtil.deleteDir(patchVersionDirectory);
final String patchName =SharePatchFileUtil.getPatchVersionDirectory(patchMd5);
final String patchVersionDirectory = patchDirectory + "/" +patchName;
TinkerLog.i(TAG, "UpgradePatchtryPatch:patchVersionDirectory:%s", patchVersionDirectory);
//copy file
File destPatchFile = new File(patchVersionDirectory + "/" +SharePatchFileUtil.getPatchVersionFile(patchMd5));
try {
// check md5 first
if (!patchMd5.equals(SharePatchFileUtil.getMD5(destPatchFile))) {
SharePatchFileUtil.copyFileUsingStream(patchFile,destPatchFile);
TinkerLog.w(TAG, "UpgradePatch copy patch file, src file: %s size:%d, dest file: %s size:%d", patchFile.getAbsolutePath(),patchFile.length(),
destPatchFile.getAbsolutePath(),destPatchFile.length());
}
}catch (IOException e) {
// e.printStackTrace();
TinkerLog.e(TAG, "UpgradePatch tryPatch:copy patch file fail from%s to %s", patchFile.getPath(), destPatchFile.getPath());
manager.getPatchReporter().onPatchTypeExtractFail(patchFile,destPatchFile, patchFile.getName(), ShareConstants.TYPE_PATCH_FILE);
return false;
}
//we use destPatchFile instead of patchFile, because patchFile maybe deleted during the patch process
//开始合并修复dex文件。
tryRecoverDexFiles（）→patchDexExtractViaDexDiff（）→extractDexDiffInternals（）→dexOptimizeDexFiles（）
if(!DexDiffPatchInternal.tryRecoverDexFiles(manager, signatureCheck, context,patchVersionDirectory, destPatchFile)) {
TinkerLog.e(TAG, "UpgradePatch tryPatch:new patch recover, trypatch dex failed");
return false;
}
if(!BsDiffPatchInternal.tryRecoverLibraryFiles(manager, signatureCheck, context,patchVersionDirectory, destPatchFile)) {
TinkerLog.e(TAG, "UpgradePatch tryPatch:new patch recover, trypatch library failed");
return false;
}
if(!ResDiffPatchInternal.tryRecoverResourceFiles(manager, signatureCheck,context, patchVersionDirectory, destPatchFile)) {
TinkerLog.e(TAG, "UpgradePatch tryPatch:new patch recover, trypatch resource failed");
return false;
}
//check dex opt file at last, some phone such as VIVO/OPPO like to change dex2oatto interpreted
if(!DexDiffPatchInternal.waitAndCheckDexOptFile(patchFile, manager)) {
TinkerLog.e(TAG, "UpgradePatch tryPatch:new patch recover, checkdex opt file failed");
return false;
}
if(!SharePatchInfo.rewritePatchInfoFileWithLock(patchInfoFile, newInfo,patchInfoLockFile)) {
TinkerLog.e(TAG, "UpgradePatch tryPatch:new patch recover, rewritepatch info failed");
manager.getPatchReporter().onPatchInfoCorrupted(patchFile,newInfo.oldVersion, newInfo.newVersion);
return false;
}
TinkerLog.w(TAG, "UpgradePatch tryPatch: done, it is ok");
return true;
}
获取安装包的MD5签名：
@SuppressLint("PackageManagerGetSignatures")
private void init(Context context) {
ByteArrayInputStream stream = null;
try {
PackageManager pm = context.getPackageManager();
String packageName = context.getPackageName();
PackageInfo packageInfo = pm.getPackageInfo(packageName,PackageManager.GET_SIGNATURES);
mPublicKeyMd5 =SharePatchFileUtil.getMD5(packageInfo.signatures[0].toByteArray());
if (mPublicKeyMd5 == null) {
throw new TinkerRuntimeException("get public key md5 isnull");
}
}catch (Exception e) {
throw new TinkerRuntimeException("ShareSecurityCheck init publickey fail", e);
}finally {
SharePatchFileUtil.closeQuietly(stream);
}
}
可以使用jdk中的properties类，实现hashtable和xml文件之间的相互转换，非常方便。
代码如下：
Properties properties = new Properties();
FileInputStream inputStream = null;
try {
inputStream = new FileInputStream(pathInfoFile);
properties.load(inputStream);//加载文件
oldVer = properties.getProperty(OLD_VERSION);//根据key获取相应的值。
newVer = properties.getProperty(NEW_VERSION);
lastFingerPrint = properties.getProperty(FINGER_PRINT);
oatDIr = properties.getProperty(OAT_DIR);
parseDexDiffPatchInfo():把生成的patch文件中，与dex文件修改相关的信息提取出来。
public static void parseDexDiffPatchInfo(Stringmeta, ArrayList<ShareDexDiffPatchInfo> dexList) {
if(meta == null || meta.length() == 0) {
return;
}
String[] lines = meta.split("\n");
for (final String line : lines) {
if (line == null || line.length() <= 0) {
continue;
}
final String[] kv = line.split(",", 8);
if (kv == null || kv.length < 8) {
continue;
}
// key
final String name = kv[0].trim();
final String path = kv[1].trim();
final String destMd5InDvm =kv[2].trim();
final String destMd5InArt =kv[3].trim();
final String dexDiffMd5 =kv[4].trim();
final String oldDexCrc = kv[5].trim();
final String newDexCrc =kv[6].trim();
final StringdexMode = kv[7].trim();
ShareDexDiffPatchInfo dexInfo = new ShareDexDiffPatchInfo(name, path,destMd5InDvm, destMd5InArt,
dexDiffMd5, oldDexCrc, newDexCrc, dexMode);
dexList.add(dexInfo);
}
}
extractDexDiffInternals（）
private static boolean extractDexDiffInternals(Context context, String dir,String meta, File patchFile, int type) {
//parse
patchList.clear();
//根据patch生成时的记录将每一个改动对应的封装对象加入到patchList中，封装对象字段包括：
this.rawName= name;
this.path = path;
this.destMd5InDvm = destMd5InDvm;
this.destMd5InArt = destMd5InArt;
this.dexDiffMd5 = dexDiffMd5;
this.oldDexCrC = oldDexCrc;
this.newDexCrC = newDexCrC;
this.dexMode = dexMode;
if(dexMode.equals(ShareConstants.DEXMODE_JAR)) {
this.isJarMode = true;
if(SharePatchFileUtil.isRawDexFile(name)) {
realName = name +ShareConstants.JAR_SUFFIX;
} else {
realName = name;
}
} else if(dexMode.equals(ShareConstants.DEXMODE_RAW)) {
this.isJarMode = false;
this.realName = name;
} else {
throw newTinkerRuntimeException("can't recognize dex mode:" + dexMode);
ShareDexDiffPatchInfo.parseDexDiffPatchInfo(meta, patchList);
if(patchList.isEmpty()) {
TinkerLog.w(TAG, "extract patchlist is empty! type:%s:", ShareTinkerInternals.getTypeString(type));
return true;
}
File directory = new File(dir);
if(!directory.exists()) {
directory.mkdirs();
}
//I think it is better to extract the raw files from apk
Tinker manager = Tinker.with(context);
ZipFile apk = null;
ZipFile patch = null;
try {
ApplicationInfo applicationInfo = context.getApplicationInfo();
if (applicationInfo == null) {
// Looks like running on a test Context, so just return withoutpatching.
TinkerLog.w(TAG, "applicationInfo == null!!!!");
return false;
}
String apkPath = applicationInfo.sourceDir;
apk = new ZipFile(apkPath);
patch = new ZipFile(patchFile);
//dir:patch/dex/
if (checkClassNDexFiles(dir)) {
TinkerLog.w(TAG, "class n dex file %s is already exist, and md5match, just continue", ShareConstants.CLASS_N_APK_NAME);
return true;
}
for (ShareDexDiffPatchInfo info : patchList) {
long start = System.currentTimeMillis();
final String infoPath =info.path;
String patchRealPath;
if (infoPath.equals("")) {
patchRealPath =info.rawName;
} else {
patchRealPath = info.path +"/" + info.rawName;
}
String dexDiffMd5 = info.dexDiffMd5;
String oldDexCrc = info.oldDexCrC;
if (!isVmArt && info.destMd5InDvm.equals("0")) {
TinkerLog.w(TAG,"patch dex %s is only for art, just continue", patchRealPath);
continue;
}
String extractedFileMd5 = isVmArt ? info.destMd5InArt :info.destMd5InDvm;
if (!SharePatchFileUtil.checkIfMd5Valid(extractedFileMd5)) {
TinkerLog.w(TAG, "metafile md5 invalid, type:%s, name: %s, md5: %s",ShareTinkerInternals.getTypeString(type), info.rawName, extractedFileMd5);
manager.getPatchReporter().onPatchPackageCheckFail(patchFile,BasePatchInternal.getMetaCorruptedCode(type));
return false;
}
File extractedFile = new File(dir + info.realName);
//check file whether already exist
if (extractedFile.exists()) {
if(SharePatchFileUtil.verifyDexFileMd5(extractedFile, extractedFileMd5)) {
//it is ok, justcontinue
TinkerLog.w(TAG,"dex file %s is already exist, and md5 match, just continue",extractedFile.getPath());
continue;
} else {
TinkerLog.w(TAG,"have a mismatch corrupted dex " + extractedFile.getPath());
extractedFile.delete();
}
} else {
extractedFile.getParentFile().mkdirs();
}
ZipEntry patchFileEntry = patch.getEntry(patchRealPath);
ZipEntry rawApkFileEntry =apk.getEntry(patchRealPath);
if (oldDexCrc.equals("0")) {
if (patchFileEntry == null){
TinkerLog.w(TAG,"patch entry is null. path:" + patchRealPath);
manager.getPatchReporter().onPatchTypeExtractFail(patchFile,extractedFile, info.rawName, type);
return false;
}
//it is a new file, butmaybe we need to repack the dex file
if (!extractDexFile(patch,patchFileEntry, extractedFile, info)) {
TinkerLog.w(TAG,"Failed to extract raw patch file " + extractedFile.getPath());
manager.getPatchReporter().onPatchTypeExtractFail(patchFile,extractedFile, info.rawName, type);
return false;
}
} else if (dexDiffMd5.equals("0")) {
// skip process old dex forreal dalvik vm
if (!isVmArt) {
continue;
}
if (rawApkFileEntry ==null) {
TinkerLog.w(TAG,"apk entry is null. path:" + patchRealPath);
manager.getPatchReporter().onPatchTypeExtractFail(patchFile,extractedFile, info.rawName, type);
return false;
}
//check source crc insteadof md5 for faster
String rawEntryCrc =String.valueOf(rawApkFileEntry.getCrc());
if(!rawEntryCrc.equals(oldDexCrc)) {
TinkerLog.e(TAG,"apk entry %s crc is not equal, expect crc: %s, got crc: %s",patchRealPath, oldDexCrc, rawEntryCrc);
manager.getPatchReporter().onPatchTypeExtractFail(patchFile,extractedFile, info.rawName, type);
return false;
}
// Small patched dexgenerating strategy was disabled, we copy full original dex directly now.
//patchDexFile(apk, patch,rawApkFileEntry, null, info, smallPatchInfoFile, extractedFile);
extractDexFile(apk,rawApkFileEntry, extractedFile, info);
if(!SharePatchFileUtil.verifyDexFileMd5(extractedFile, extractedFileMd5)) {
TinkerLog.w(TAG,"Failed to recover dex file when verify patched dex: " + extractedFile.getPath());
manager.getPatchReporter().onPatchTypeExtractFail(patchFile,extractedFile, info.rawName, type);
SharePatchFileUtil.safeDeleteFile(extractedFile);
return false;
}
} else {
if (patchFileEntry == null){
TinkerLog.w(TAG,"patch entry is null. path:" + patchRealPath);
manager.getPatchReporter().onPatchTypeExtractFail(patchFile,extractedFile, info.rawName, type);
return false;
}
if(!SharePatchFileUtil.checkIfMd5Valid(dexDiffMd5)) {
TinkerLog.w(TAG,"meta file md5 invalid, type:%s, name: %s, md5: %s",ShareTinkerInternals.getTypeString(type), info.rawName, dexDiffMd5);
manager.getPatchReporter().onPatchPackageCheckFail(patchFile,BasePatchInternal.getMetaCorruptedCode(type));
return false;
}
if (rawApkFileEntry ==null) {
TinkerLog.w(TAG,"apk entry is null. path:" + patchRealPath);
manager.getPatchReporter().onPatchTypeExtractFail(patchFile, extractedFile,info.rawName, type);
return false;
}
//check source crc insteadof md5 for faster
String rawEntryCrc =String.valueOf(rawApkFileEntry.getCrc());
if(!rawEntryCrc.equals(oldDexCrc)) {
TinkerLog.e(TAG,"apk entry %s crc is not equal, expect crc: %s, got crc: %s",patchRealPath, oldDexCrc, rawEntryCrc);
manager.getPatchReporter().onPatchTypeExtractFail(patchFile,extractedFile, info.rawName, type);
return false;
}
patchDexFile(apk, patch,rawApkFileEntry, patchFileEntry, info, extractedFile);
if (!SharePatchFileUtil.verifyDexFileMd5(extractedFile,extractedFileMd5)) {
TinkerLog.w(TAG,"Failed to recover dex file when verify patched dex: " +extractedFile.getPath());
manager.getPatchReporter().onPatchTypeExtractFail(patchFile,extractedFile, info.rawName, type);
SharePatchFileUtil.safeDeleteFile(extractedFile);
return false;
}
TinkerLog.w(TAG,"success recover dex file: %s, size: %d, use time: %d",
extractedFile.getPath(), extractedFile.length(),(System.currentTimeMillis() - start));
}
}
if (!mergeClassNDexFiles(context, patchFile, dir)) {
return false;
}
}catch (Throwable e) {
throw new TinkerRuntimeException("patch " +ShareTinkerInternals.getTypeString(type) + " extract failed (" +e.getMessage() + ").", e);
}finally {
SharePatchFileUtil.closeZip(apk);
SharePatchFileUtil.closeZip(patch);
}
return true;
}