Android热修复Tinker接入及源码解读

dependencies {
  // ...
  //可选，用于生成application类
  provided('com.tencent.tinker:tinker-android-anno:1.7.7')
  //tinker的核心库
  compile('com.tencent.tinker:tinker-android-lib:1.7.7')
}

android{
 //...
  signingConfigs {
    release {      try {
        storeFile file("release.keystore")
        storePassword "testres"
        keyAlias "testres"
        keyPassword "testres"
      } catch (ex) {
        throw new InvalidUserDataException(ex.toString())
      }
    }
  }

  buildTypes {
    release {
      minifyEnabled true
      signingConfig signingConfigs.release
      proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
    }
    debug {
      debuggable true
      minifyEnabled true
      signingConfig signingConfigs.release
      proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
    }
  }
}

@DefaultLifeCycle(application = ".SimpleTinkerInApplication",
    flags = ShareConstants.TINKER_ENABLE_ALL,
    loadVerifyFlag = false)public class SimpleTinkerInApplicationLike extends ApplicationLike {
  public SimpleTinkerInApplicationLike(Application application, int tinkerFlags, boolean tinkerLoadVerifyFlag, long applicationStartElapsedTime, long applicationStartMillisTime, Intent tinkerResultIntent) {    super(application, tinkerFlags, tinkerLoadVerifyFlag, applicationStartElapsedTime, applicationStartMillisTime, tinkerResultIntent);
  }  @Override
  public void onBaseContextAttached(Context base) {    super.onBaseContextAttached(base);
  }  @Override
  public void onCreate() {    super.onCreate();
    TinkerInstaller.install(this);
  }
}

 <application
    android:name=".SimpleTinkerInApplication"
    .../>

public class MainActivity extends AppCompatActivity {

  @Override
  protected void onCreate(Bundle savedInstanceState) {    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
  }  public void loadPatch(View view) {
    TinkerInstaller.onReceiveUpgradePatch(getApplicationContext(),
        Environment.getExternalStorageDirectory().getAbsolutePath() + "/patch_signed.apk");
  }
}

<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />

<application>
 <meta-data
      android:name="TINKER_ID"
      android:value="tinker_id_6235657" />
  //...</application>

java -jar tinker-patch-cli-1.7.7.jar -old old.apk -new new.apk -config tinker_config.xml -out output

<loader value="com.zhy.tinkersimplein.SimpleTinkerInApplication"/>

-applymapping mapping.txt

./gradlew tinkerPatchRelease // 或者 ./gradlew tinkerPatchDebug

ext {
  tinkerEnabled = true
  //old apk file to build patch apk
  tinkerOldApkPath = "${bakPath}/old.apk"
  //proguard mapping file to build patch apk
  tinkerApplyMappingPath = "${bakPath}/old-mapping.txt"}

//可选，用于生成application类provided('com.tencent.tinker:tinker-android-anno:1.7.7')

@Overridepublic boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
  processDefaultLifeCycle(roundEnv.getElementsAnnotatedWith(DefaultLifeCycle.class));  return true;
}

private void processDefaultLifeCycle(Set<? extends Element> elements) {    // 被注解DefaultLifeCycle标识的对象
    for (Element e : elements) {     // 拿到DefaultLifeCycle注解对象
      DefaultLifeCycle ca = e.getAnnotation(DefaultLifeCycle.class);

      String lifeCycleClassName = ((TypeElement) e).getQualifiedName().toString();
      String lifeCyclePackageName = lifeCycleClassName.substring(0, lifeCycleClassName.lastIndexOf('.'));
      lifeCycleClassName = lifeCycleClassName.substring(lifeCycleClassName.lastIndexOf('.') + 1);

      String applicationClassName = ca.application();      if (applicationClassName.startsWith(".")) {
        applicationClassName = lifeCyclePackageName + applicationClassName;
      }
      String applicationPackageName = applicationClassName.substring(0, applicationClassName.lastIndexOf('.'));
      applicationClassName = applicationClassName.substring(applicationClassName.lastIndexOf('.') + 1);

      String loaderClassName = ca.loaderClass();      if (loaderClassName.startsWith(".")) {
        loaderClassName = lifeCyclePackageName + loaderClassName;
      }       // /TinkerAnnoApplication.tmpl
      final InputStream is = AnnotationProcessor.class.getResourceAsStream(APPLICATION_TEMPLATE_PATH);      final Scanner scanner = new Scanner(is);      final String template = scanner.useDelimiter("\\A").next();      final String fileContent = template
        .replaceAll("%PACKAGE%", applicationPackageName)
        .replaceAll("%APPLICATION%", applicationClassName)
        .replaceAll("%APPLICATION_LIFE_CYCLE%", lifeCyclePackageName + "." + lifeCycleClassName)
        .replaceAll("%TINKER_FLAGS%", "" + ca.flags())
        .replaceAll("%TINKER_LOADER_CLASS%", "" + loaderClassName)
        .replaceAll("%TINKER_LOAD_VERIFY_FLAG%", "" + ca.loadVerifyFlag());
        JavaFileObject fileObject = processingEnv.getFiler().createSourceFile(applicationPackageName + "." + applicationClassName);
        processingEnv.getMessager().printMessage(Diagnostic.Kind.NOTE, "Creating " + fileObject.toUri());
     Writer writer = fileObject.openWriter();
      PrintWriter pw = new PrintWriter(writer);
      pw.print(fileContent);
      pw.flush();
      writer.close();

    }
  }

package %PACKAGE%;import com.tencent.tinker.loader.app.TinkerApplication;/**
 *
 * Generated application for tinker life cycle
 *
 */public class %APPLICATION% extends TinkerApplication {

  public %APPLICATION%() {    super(%TINKER_FLAGS%, "%APPLICATION_LIFE_CYCLE%", "%TINKER_LOADER_CLASS%", %TINKER_LOAD_VERIFY_FLAG%);
  }

}

@DefaultLifeCycle(application = ".SimpleTinkerInApplication",
    flags = ShareConstants.TINKER_ENABLE_ALL,
    loadVerifyFlag = false)public class SimpleTinkerInApplicationLike extends ApplicationLike {}

/**
 *
 * Generated application for tinker life cycle
 *
 */public class SimpleTinkerInApplication extends TinkerApplication {

  public SimpleTinkerInApplication() {    super(7, "com.zhy.tinkersimplein.SimpleTinkerInApplicationLike", "com.tencent.tinker.loader.TinkerLoader", false);
  }

}

@Overridepublic Intent tryLoad(TinkerApplication app, int tinkerFlag, boolean tinkerLoadVerifyFlag) {
  Intent resultIntent = new Intent();  long begin = SystemClock.elapsedRealtime();
  tryLoadPatchFilesInternal(app, tinkerFlag, tinkerLoadVerifyFlag, resultIntent);  long cost = SystemClock.elapsedRealtime() - begin;
  ShareIntentUtil.setIntentPatchCostTime(resultIntent, cost);  return resultIntent;
}

private void tryLoadPatchFilesInternal(TinkerApplication app, int tinkerFlag, boolean tinkerLoadVerifyFlag, Intent resultIntent) {  // 省略大量安全性校验代码

  if (isEnabledForDex) {    //tinker/patch.info/patch-641e634c/dex
    boolean dexCheck = TinkerDexLoader.checkComplete(patchVersionDirectory, securityCheck, resultIntent);    if (!dexCheck) {      //file not found, do not load patch
      Log.w(TAG, "tryLoadPatchFiles:dex check fail");      return;
    }
  }  //now we can load patch jar
  if (isEnabledForDex) {    boolean loadTinkerJars = TinkerDexLoader.loadTinkerJars(app, tinkerLoadVerifyFlag, patchVersionDirectory, resultIntent, isSystemOTA);    if (!loadTinkerJars) {
      Log.w(TAG, "tryLoadPatchFiles:onPatchLoadDexesFail");      return;
    }
  }
}

@TargetApi(Build.VERSION_CODES.ICE_CREAM_SANDWICH)public static boolean loadTinkerJars(Application application, boolean tinkerLoadVerifyFlag, 
  String directory, Intent intentResult, boolean isSystemOTA) {
    PathClassLoader classLoader = (PathClassLoader) TinkerDexLoader.class.getClassLoader();

    String dexPath = directory + "/" + DEX_PATH + "/";
    File optimizeDir = new File(directory + "/" + DEX_OPTIMIZE_PATH);

    ArrayList<File> legalFiles = new ArrayList<>();    final boolean isArtPlatForm = ShareTinkerInternals.isVmArt();    for (ShareDexDiffPatchInfo info : dexList) {      //for dalvik, ignore art support dex
      if (isJustArtSupportDex(info)) {        continue;
      }
      String path = dexPath + info.realName;
      File file = new File(path);

      legalFiles.add(file);
    }    // just for art
    if (isSystemOTA) {
      parallelOTAResult = true;
      parallelOTAThrowable = null;
      Log.w(TAG, "systemOTA, try parallel oat dexes!!!!!");

      TinkerParallelDexOptimizer.optimizeAll(
        legalFiles, optimizeDir,        new TinkerParallelDexOptimizer.ResultCallback() {
        }
      );

    SystemClassLoaderAdder.installDexes(application, classLoader, optimizeDir, legalFiles);    return true;
  }

@SuppressLint("NewApi")public static void installDexes(Application application, PathClassLoader loader, File dexOptDir, List<File> files)  throws Throwable {  if (!files.isEmpty()) {
    ClassLoader classLoader = loader;    if (Build.VERSION.SDK_INT >= 24) {
      classLoader = AndroidNClassLoader.inject(loader, application);
    }    //because in dalvik, if inner class is not the same classloader with it wrapper class.
    //it won't fail at dex2opt
    if (Build.VERSION.SDK_INT >= 23) {
      V23.install(classLoader, files, dexOptDir);
    } else if (Build.VERSION.SDK_INT >= 19) {
      V19.install(classLoader, files, dexOptDir);
    } else if (Build.VERSION.SDK_INT >= 14) {
      V14.install(classLoader, files, dexOptDir);
    } else {
      V4.install(classLoader, files, dexOptDir);
    }    //install done
    sPatchDexCount = files.size();
    Log.i(TAG, "after loaded classloader: " + classLoader + ", dex size:" + sPatchDexCount);    if (!checkDexInstall(classLoader)) {      //reset patch dex
      SystemClassLoaderAdder.uninstallPatchDex(classLoader);      throw new TinkerRuntimeException(ShareConstants.CHECK_DEX_INSTALL_FAIL);
    }
  }
}

private static final class V19 {

  private static void install(ClassLoader loader, List<File> additionalClassPathEntries,
                File optimizedDirectory)    throws IllegalArgumentException, IllegalAccessException,
    NoSuchFieldException, InvocationTargetException, NoSuchMethodException, IOException {

    Field pathListField = ShareReflectUtil.findField(loader, "pathList");
    Object dexPathList = pathListField.get(loader);
    ArrayList<IOException> suppressedExceptions = new ArrayList<IOException>();
    ShareReflectUtil.expandFieldArray(dexPathList, "dexElements", makeDexElements(dexPathList,      new ArrayList<File>(additionalClassPathEntries), optimizedDirectory,
      suppressedExceptions));    if (suppressedExceptions.size() > 0) {      for (IOException e : suppressedExceptions) {
        Log.w(TAG, "Exception in makeDexElement", e);        throw e;
      }
    }
  }
}

 TinkerInstaller.onReceiveUpgradePatch(getApplicationContext(),
        Environment.getExternalStorageDirectory().getAbsolutePath() + "/patch_signed.apk");

# DefaultPatchListener@Overridepublic int onPatchReceived(String path) {  int returnCode = patchCheck(path);  if (returnCode == ShareConstants.ERROR_PATCH_OK) {
    TinkerPatchService.runPatchService(context, path);
  } else {
    Tinker.with(context).getLoadReporter().onLoadPatchListenerReceiveFail(new File(path), returnCode);
  }  return returnCode;

}

public static void runPatchService(Context context, String path) {  try {
    Intent intent = new Intent(context, TinkerPatchService.class);
    intent.putExtra(PATCH_PATH_EXTRA, path);
    intent.putExtra(RESULT_CLASS_EXTRA, resultServiceClass.getName());
    context.startService(intent);
  } catch (Throwable throwable) {
    TinkerLog.e(TAG, "start patch service fail, exception:" + throwable);
  }
}

@Overrideprotected void onHandleIntent(Intent intent) {  final Context context = getApplicationContext();
  Tinker tinker = Tinker.with(context);


  String path = getPatchPathExtra(intent);

  File patchFile = new File(path);  boolean result;

  increasingPriority();
  PatchResult patchResult = new PatchResult();

  result = upgradePatchProcessor.tryPatch(context, path, patchResult);

  patchResult.isSuccess = result;
  patchResult.rawPatchFilePath = path;
  patchResult.costTime = cost;
  patchResult.e = e;

  AbstractResultService.runResultService(context, patchResult, getPatchResultExtra(intent));

}

private void increasingPriority() {
  TinkerLog.i(TAG, "try to increase patch process priority");  try {
    Notification notification = new Notification();    if (Build.VERSION.SDK_INT < 18) {
      startForeground(notificationId, notification);
    } else {
      startForeground(notificationId, notification);      // start InnerService
      startService(new Intent(this, InnerService.class));
    }
  } catch (Throwable e) {
    TinkerLog.i(TAG, "try to increase patch process priority error:" + e);
  }
}

# UpgradePatch@Overridepublic boolean tryPatch(Context context, String tempPatchPath, PatchResult patchResult) {
  Tinker manager = Tinker.with(context);  final File patchFile = new File(tempPatchPath);  //it is a new patch, so we should not find a exist
  SharePatchInfo oldInfo = manager.getTinkerLoadResultIfPresent().patchInfo;
  String patchMd5 = SharePatchFileUtil.getMD5(patchFile);  //use md5 as version
  patchResult.patchVersion = patchMd5;
  SharePatchInfo newInfo;  //already have patch
  if (oldInfo != null) {
    newInfo = new SharePatchInfo(oldInfo.oldVersion, patchMd5, Build.FINGERPRINT);
  } else {
    newInfo = new SharePatchInfo("", patchMd5, Build.FINGERPRINT);
  }  //check ok, we can real recover a new patch
  final String patchDirectory = manager.getPatchDirectory().getAbsolutePath();  final String patchName = SharePatchFileUtil.getPatchVersionDirectory(patchMd5);  final String patchVersionDirectory = patchDirectory + "/" + patchName;  //copy file
  File destPatchFile = new File(patchVersionDirectory + "/" + SharePatchFileUtil.getPatchVersionFile(patchMd5));  // check md5 first
  if (!patchMd5.equals(SharePatchFileUtil.getMD5(destPatchFile))) {
    SharePatchFileUtil.copyFileUsingStream(patchFile, destPatchFile);
  }  //we use destPatchFile instead of patchFile, because patchFile may be deleted during the patch process
  if (!DexDiffPatchInternal.tryRecoverDexFiles(manager, signatureCheck, context, patchVersionDirectory, 
        destPatchFile)) {
    TinkerLog.e(TAG, "UpgradePatch tryPatch:new patch recover, try patch dex failed");    return false;
  }  return true;
}

protected static boolean tryRecoverDexFiles(Tinker manager, ShareSecurityCheck checker, Context context,
                        String patchVersionDirectory, File patchFile) {
  String dexMeta = checker.getMetaContentMap().get(DEX_META_FILE);  boolean result = patchDexExtractViaDexDiff(context, patchVersionDirectory, dexMeta, patchFile);  return result;
}

private static boolean patchDexExtractViaDexDiff(Context context, String patchVersionDirectory, String meta, final File patchFile) {
  String dir = patchVersionDirectory + "/" + DEX_PATH + "/";  if (!extractDexDiffInternals(context, dir, meta, patchFile, TYPE_DEX)) {
    TinkerLog.w(TAG, "patch recover, extractDiffInternals fail");    return false;
  }  final Tinker manager = Tinker.with(context);

  File dexFiles = new File(dir);
  File[] files = dexFiles.listFiles();

  ...files遍历执行：DexFile.loadDex   return true;
}

private static boolean extractDexDiffInternals(Context context, String dir, String meta, File patchFile, int type) {  //parse meta
  ArrayList<ShareDexDiffPatchInfo> patchList = new ArrayList<>();
  ShareDexDiffPatchInfo.parseDexDiffPatchInfo(meta, patchList);

  File directory = new File(dir);  //I think it is better to extract the raw files from apk
  Tinker manager = Tinker.with(context);
  ZipFile apk = null;
  ZipFile patch = null;

  ApplicationInfo applicationInfo = context.getApplicationInfo();

  String apkPath = applicationInfo.sourceDir; //base.apk
  apk = new ZipFile(apkPath);
  patch = new ZipFile(patchFile);  for (ShareDexDiffPatchInfo info : patchList) {    final String infoPath = info.path;
    String patchRealPath;    if (infoPath.equals("")) {
      patchRealPath = info.rawName;
    } else {
      patchRealPath = info.path + "/" + info.rawName;
    }

    File extractedFile = new File(dir + info.realName);

    ZipEntry patchFileEntry = patch.getEntry(patchRealPath);
    ZipEntry rawApkFileEntry = apk.getEntry(patchRealPath);

    patchDexFile(apk, patch, rawApkFileEntry, patchFileEntry, info, extractedFile);
  }  return true;
}

private static void patchDexFile(
      ZipFile baseApk, ZipFile patchPkg, ZipEntry oldDexEntry, ZipEntry patchFileEntry,
      ShareDexDiffPatchInfo patchInfo, File patchedDexFile) throws IOException {
  InputStream oldDexStream = null;
  InputStream patchFileStream = null;

  oldDexStream = new BufferedInputStream(baseApk.getInputStream(oldDexEntry));
  patchFileStream = (patchFileEntry != null ? new BufferedInputStream(patchPkg.getInputStream(patchFileEntry)) : null);  new DexPatchApplier(oldDexStream, patchFileStream).executeAndSaveTo(patchedDexFile);

}