Tinker

Tinker流程介绍

"你好，未来"

Posted by one_cup on 2016-12-26

Tinker 流程介绍

最近在开发过程中遇到一个Tinker相关的问题，正好之前研究的不够透彻，借着机会好好的学习学习，本文不涉及核心的diff算法，我也不会，就是走一遍流程，看看Tinker在我们的app中都做了哪些事情。

编译期

使用过Tinker的都应该很清楚，我们在使用的时候需要自己写一个applicationlike,然后写一个注解，标注一下，这个注解的作用就是生成一个真正的application(在编译期)，而生成的application是集成TinkerApplication,只有一个super方法，参数有我们写的applicationlike和tinkerloader

1
2
3
4
5
6
7
8
	public class SampleApplication extends TinkerApplication {
    public SampleApplication() {
        super(7, "tinker.sample.android.app.SampleApplicationLike", "com.tencent.tinker.loader.TinkerLoader", false);
    }
}

其实应该还有很多动作，不过不了解就不多说了。

运行期

app运行的时候最开始启动的是之前自动生成的application也就是上文中的SampleApplication,调用父类构造函数，参数赋值 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
	  protected TinkerApplication(int tinkerFlags, String delegateClassName,
                                String loaderClassName, boolean tinkerLoadVerifyFlag) {
        this.tinkerFlags = tinkerFlags;
        this.delegateClassName = delegateClassName;
        this.loaderClassName = loaderClassName;
        this.tinkerLoadVerifyFlag = tinkerLoadVerifyFlag;
    }
``` 
 
由于TinkerApplication是继承的Application，也就是说是真正的Application，那么按照接下来应该是调用attachBaseContext()方法，内部调用了onBaseContextAttached（base）方法。  
```java
	private void onBaseContextAttached(Context base) {
        applicationStartElapsedTime = SystemClock.elapsedRealtime();
        applicationStartMillisTime = System.currentTimeMillis();
		//加载TinkerLoader
        loadTinker();
		//确定代理
        ensureDelegate();
		//执行代理的onBaseContextAttached方法
        try {
            Method method = ShareReflectUtil.findMethod(delegate, "onBaseContextAttached", Context.class);
            method.invoke(delegate, base);
        } catch (Throwable t) {
            throw new TinkerRuntimeException("onBaseContextAttached method not found", t);
        }
        //reset save mode
        if (useSafeMode) {
            String processName = ShareTinkerInternals.getProcessName(this);
            String preferName = ShareConstants.TINKER_OWN_PREFERENCE_CONFIG + processName;
            SharedPreferences sp = getSharedPreferences(preferName, Context.MODE_PRIVATE);
            sp.edit().putInt(ShareConstants.TINKER_SAFE_MODE_COUNT, 0).commit();
        }
    }
	/*
	*利用初始化获得的字符串反射获得TinkerLoader，执行tryLoad方法，进行一系列检查，之后将结果赋值到Intent中返回
	*/
	private void loadTinker() {
        //disable tinker, not need to install
        if (tinkerFlags == TINKER_DISABLE) {
            return;
        }
        tinkerResultIntent = new Intent();
        try {
            //reflect tinker loader, because loaderClass may be define by user!
            Class<?> tinkerLoadClass = Class.forName(loaderClassName, false, getClassLoader());
            Method loadMethod = tinkerLoadClass.getMethod(TINKER_LOADER_METHOD, TinkerApplication.class, int.class, boolean.class);
            Constructor<?> constructor = tinkerLoadClass.getConstructor();
            tinkerResultIntent = (Intent) loadMethod.invoke(constructor.newInstance(), this, tinkerFlags, tinkerLoadVerifyFlag);
        } catch (Throwable e) {
            //has exception, put exception error code
            ShareIntentUtil.setIntentReturnCode(tinkerResultIntent, ShareConstants.ERROR_LOAD_PATCH_UNKNOWN_EXCEPTION);
            tinkerResultIntent.putExtra(INTENT_PATCH_EXCEPTION, e);
        }
    }

接下来，让我们的重点来到Tinker的初始化。在执行ApplicationLike的onBaseContextAttached方法的时候会执行TinkerInstaller.install(this),这里的this就是applicationlike。最终会执行到Tinker.install()方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
	
public void install(Intent intentResult, Class<? extends AbstractResultService> serviceClass,
                      AbstractPatch upgradePatch) {
      sInstalled = true;
      TinkerPatchService.setPatchProcessor(upgradePatch, serviceClass);
      if (!isTinkerEnabled()) {
          TinkerLog.e(TAG, "tinker is disabled");
          return;
      }
      if (intentResult == null) {
          throw new TinkerRuntimeException("intentResult must not be null.");
      }
      tinkerLoadResult = new TinkerLoadResult();
      tinkerLoadResult.parseTinkerResult(getContext(), intentResult);
      //after load code set
      loadReporter.onLoadResult(patchDirectory, tinkerLoadResult.loadCode, tinkerLoadResult.costTime);
      if (!loaded) {
          TinkerLog.w(TAG, "tinker load fail!");
      }
  }

到此，Tinker的初始化就完成了，由于使用的是单例模式，所以之后的Tinker.with(applicationlike)所产生的对象都是一样的。简单说一下整体的逻辑：

  1. 自动生成的application调用父类方法，传入applicationlike和TinkerLoader的包名。
  2. 真正的Application中的attachBaseContext方法中通过反射，执行TinkerLoader的tryLoad方法，将结果保存到intent中。同样通过反射得到applicationlike对象，执行onBaseContextAttech（）方法。
  3. 在applicationlike的onBaseContextAttech()方法中执行Tinker的初始化，设置默认的相关类，并且设置补丁进程服务属性，打印相关信息

加载

Tinker的1.7.6版本中将repairPatch已经删掉了。这里只介绍一下升级就是UpgradePatch的调用，首先是onReceiveUpgradepatch()方法，入参是application和路径。之后会使用Tinker初始化时赋值的DefaultPatchListener检查路径信息。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 @Override
   public 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;
   }
protected int patchCheck(String path) {
       Tinker manager = Tinker.with(context);
       //check SharePreferences also
       if (!manager.isTinkerEnabled() || !ShareTinkerInternals.isTinkerEnableWithSharedPreferences(context)) {
           return ShareConstants.ERROR_PATCH_DISABLE;
       }
       File file = new File(path);
       if (!file.isFile() || !file.exists() || file.length() == 0) {
           return ShareConstants.ERROR_PATCH_NOTEXIST;
       }
       //patch service can not send request
       if (manager.isPatchProcess()) {
           return ShareConstants.ERROR_PATCH_INSERVICE;
       }
       //if the patch service is running, pending
       if (TinkerServiceInternals.isTinkerPatchServiceRunning(context)) {
           return ShareConstants.ERROR_PATCH_RUNNING;
       }
       return ShareConstants.ERROR_PATCH_OK;
   }

检查路径，返回值有五种

当返回成功时则会启动service，TinkerPatchService继承的是IntentService,主要的工作都是onHandleIntent()中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
@Override
  protected void onHandleIntent(Intent intent) {
      final Context context = getApplicationContext();
//获得单例模式的Tinker
      Tinker tinker = Tinker.with(context);
//打印服务开始信息
      tinker.getPatchReporter().onPatchServiceStart(intent);
      if (intent == null) {
          TinkerLog.e(TAG, "TinkerPatchService received a null intent, ignoring.");
          return;
      }
      String path = getPatchPathExtra(intent);
      if (path == null) {
          TinkerLog.e(TAG, "TinkerPatchService can't get the path extra, ignoring.");
          return;
      }
      File patchFile = new File(path);
      long begin = SystemClock.elapsedRealtime();
      boolean result;
      long cost;
      Throwable e = null;
//提高服务的进程优先级
      increasingPriority();
//创建一个补丁结果接收类
      PatchResult patchResult = new PatchResult();
      try {
          if (upgradePatchProcessor == null) {
              throw new TinkerRuntimeException("upgradePatchProcessor is null.");
          }
	//打补丁
          result = upgradePatchProcessor.tryPatch(context, path, patchResult);
      } catch (Throwable throwable) {
          e = throwable;
          result = false;
          tinker.getPatchReporter().onPatchException(patchFile, e);
      }
//计算消耗时间
      cost = SystemClock.elapsedRealtime() - begin;
//输出补丁结果日志
      tinker.getPatchReporter().
          onPatchResult(patchFile, result, cost);
      patchResult.isSuccess = result;
      patchResult.rawPatchFilePath = path;
      patchResult.costTime = cost;
      patchResult.e = e;
//根据补丁结果，来决定执行哪些操作
      AbstractResultService.runResultService(context, patchResult, getPatchResultExtra(intent));
  }

最主要的动作是在upgradePatchProcessor.tryPatch(context, path, patchResult)中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
@Override
  public boolean tryPatch(Context context, String tempPatchPath, PatchResult patchResult) {
      Tinker manager = Tinker.with(context);
      final File patchFile = new File(tempPatchPath);
      if (!manager.isTinkerEnabled() || !ShareTinkerInternals.isTinkerEnableWithSharedPreferences(context)) {
          TinkerLog.e(TAG, "UpgradePatch tryPatch:patch is disabled, just return");
          return false;
      }
      if (!patchFile.isFile() || !patchFile.exists()) {
          TinkerLog.e(TAG, "UpgradePatch tryPatch:patch file is not found, just return");
          return false;
      }
      //check the signature, we should create a new checker
//签名校验
      ShareSecurityCheck signatureCheck = new ShareSecurityCheck(context);
      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;
      }
      //it is a new patch, so we should not find a exist
      SharePatchInfo oldInfo = manager.getTinkerLoadResultIfPresent().patchInfo;
      String patchMd5 = SharePatchFileUtil.getMD5(patchFile);
      if (patchMd5 == null) {
          TinkerLog.e(TAG, "UpgradePatch tryPatch:patch md5 is null, just return");
          return false;
      }
      //use md5 as version
      patchResult.patchVersion = patchMd5;
      SharePatchInfo newInfo;
      //already have patch
      if (oldInfo != null) {
          if (oldInfo.oldVersion == null || oldInfo.newVersion == null) {
              TinkerLog.e(TAG, "UpgradePatch tryPatch:onPatchInfoCorrupted");
              manager.getPatchReporter().onPatchInfoCorrupted(patchFile, oldInfo.oldVersion, oldInfo.newVersion);
              return false;
          }
          if (oldInfo.oldVersion.equals(patchMd5) || oldInfo.newVersion.equals(patchMd5)) {
              TinkerLog.e(TAG, "UpgradePatch tryPatch:onPatchVersionCheckFail");
              manager.getPatchReporter().onPatchVersionCheckFail(patchFile, oldInfo, patchMd5);
              return false;
          }
          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();
      TinkerLog.i(TAG, "UpgradePatch tryPatch:patchMd5:%s", patchMd5);
      final String patchName = SharePatchFileUtil.getPatchVersionDirectory(patchMd5);
      final String patchVersionDirectory = patchDirectory + "/" + patchName;
      TinkerLog.i(TAG, "UpgradePatch tryPatch:patchVersionDirectory:%s", patchVersionDirectory);
      //it is a new patch, we first delete if there is any files
      //don't delete dir for faster retry
//SharePatchFileUtil.deleteDir(patchVersionDirectory);
      //copy file
//生成临时文件
      File destPatchFile = new File(patchVersionDirectory + "/" + SharePatchFileUtil.getPatchVersionFile(patchMd5));
      try {
          SharePatchFileUtil.copyFileUsingStream(patchFile, destPatchFile);
          TinkerLog.w(TAG, "UpgradePatch after %s size:%d, %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 may be deleted during the patch process
//Dexdiff算法，代码
      if (!DexDiffPatchInternal.tryRecoverDexFiles(manager, signatureCheck, context, patchVersionDirectory, destPatchFile)) {
          TinkerLog.e(TAG, "UpgradePatch tryPatch:new patch recover, try patch dex failed");
          return false;
      }
//bsDiff,lib库
      if (!BsDiffPatchInternal.tryRecoverLibraryFiles(manager, signatureCheck, context, patchVersionDirectory, destPatchFile)) {
          TinkerLog.e(TAG, "UpgradePatch tryPatch:new patch recover, try patch library failed");
          return false;
      }
//ResDiff，资源文件
      if (!ResDiffPatchInternal.tryRecoverResourceFiles(manager, signatureCheck, context, patchVersionDirectory, destPatchFile)) {
          TinkerLog.e(TAG, "UpgradePatch tryPatch:new patch recover, try patch resource failed");
          return false;
      }
      final File patchInfoFile = manager.getPatchInfoFile();
      if (!SharePatchInfo.rewritePatchInfoFileWithLock(patchInfoFile, newInfo, SharePatchFileUtil.getPatchInfoLockFile(patchDirectory))) {
          TinkerLog.e(TAG, "UpgradePatch tryPatch:new patch recover, rewrite patch info failed");
          manager.getPatchReporter().onPatchInfoCorrupted(patchFile, newInfo.oldVersion, newInfo.newVersion);
          return false;
      }
      TinkerLog.w(TAG, "UpgradePatch tryPatch: done, it is ok");
      return true;
  }

上面就是Tinker最核心的地方，各种校验比对，通过之后进行合并。剩下就是决定什么时候杀进程了。 AbstractResultService.runResultService(context, patchResult, getPatchResultExtra(intent));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
@Override
   public void onPatchResult(PatchResult result) {
       if (result == null) {
           TinkerLog.e(TAG, "DefaultTinkerResultService received null result!!!!");
           return;
       }
       TinkerLog.i(TAG, "DefaultTinkerResultService received a result:%s ", result.toString());
       //first, we want to kill the recover process
       TinkerServiceInternals.killTinkerPatchServiceProcess(getApplicationContext());
       // if success and newPatch, it is nice to delete the raw file, and restart at once
       // only main process can load an upgrade patch!
       if (result.isSuccess) {
           File rawFile = new File(result.rawPatchFilePath);
           if (rawFile.exists()) {
               TinkerLog.i(TAG, "save delete raw patch file");
               SharePatchFileUtil.safeDeleteFile(rawFile);
           }
           if (checkIfNeedKill(result)) {
               android.os.Process.killProcess(android.os.Process.myPid());
           } else {
               TinkerLog.i(TAG, "I have already install the newly patch version!");
           }
       }
   }
FEATURED TAGS
Tinker
FRIENDS