本文详细介绍了如何在Android应用中集成Tinker框架实现热更新，包括项目配置、代码修改、补丁包制作及测试流程。通过实例展示了如何在不重新打包安装的情况下加载补丁，实现应用的快速迭代。
为什么要选Tinker，从下图可以看出Tinker相比其他同类型的框架优势还是比较大的
官方接入指南
由于官方指南看起来比较迷糊，所以下面请跟我一起一步步手动实现Android热更新
第一部分，Tinker的接入
一、项目的build.gradle下，我这里tinker版本是1.9.1，你可以移步去官方文档了解一下最新的版本和配置
dependencies {
classpath 'com.android.tools.build:gradle:3.0.1'
classpath ('com.tencent.tinker:tinker-patch-gradle-plugin:1.9.1')
}
二、app的build.gradle下，上面部分是基本配置，下面是Tinker配置（可直接复制我这段代码，经过自测过，没有问题）
apply plugin: 'com.android.application'
android {
//签名配置
signingConfigs {
release {
keyAlias 'tinker'
keyPassword '123456'
storeFile file('E:/androidProjects/tinker.jks')
storePassword '123456'
}
}
compileSdkVersion 26
defaultConfig {
applicationId "example.glh.tencenthotfix"
minSdkVersion 15
targetSdkVersion 26
versionCode 1
versionName "1.0"
testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
//由于报annotation错误才引入这一句，可不用
javaCompileOptions { annotationProcessorOptions { includeCompileClasspath = true } }
// tinker 基本配置
multiDexEnabled true
buildConfigField "String", "MESSAGE", "\"I am the base apk\""
buildConfigField "String", "TINKER_ID", "\"${getTinkerIdValue()}\""
buildConfigField "String", "PLATFORM", "\"all\""
}
// Tinker 推荐设置
dexOptions {
jumboMode = true
}
buildTypes {
release {
minifyEnabled true
signingConfig signingConfigs.release
proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
}
debug {
signingConfig signingConfigs.release
}
}
configurations.all {
resolutionStrategy.force 'com.android.support:support-annotations:27.1.1'
}
}
dependencies {
implementation fileTree(include: ['*.jar'], dir: 'libs')
implementation 'com.android.support:appcompat-v7:26.1.0'
implementation 'com.android.support.constraint:constraint-layout:1.1.3'
testImplementation 'junit:junit:4.12'
androidTestImplementation 'com.android.support.test:runner:1.0.2'
androidTestImplementation 'com.android.support.test.espresso:espresso-core:3.0.2'
// 多dex 打包的类库
compile 'com.android.support:multidex:1.0.1'
//可选，用于生成application类
provided 'com.tencent.tinker:tinker-android-anno:1.9.1'
//tinker的核心库
compile 'com.tencent.tinker:tinker-android-lib:1.9.1'
}
//=======================Tinker 配置=======================================
def gitSha() {
try {
// String gitRev = 'git rev-parse --short HEAD'.execute(null, project.rootDir).text.trim()
String gitRev = "1008611"
if (gitRev == null) {
throw new GradleException("can't get git rev, you should add git to system path or just input test value, such as 'testTinkerId'")
}
return gitRev
} catch (Exception e) {
throw new GradleException("can't get git rev, you should add git to system path or just input test value, such as 'testTinkerId'")
}
}
def bakPath = file("${buildDir}/bakApk/")
ext {
//for some reason, you may want to ignore tinkerBuild, such as instant run debug build?
tinkerEnabled = true
//for normal build
//old apk file to build patch apk
tinkerOldApkPath = "${bakPath}/app-release-0426-14-59-42.apk"
//proguard mapping file to build patch apk
tinkerApplyMappingPath = "${bakPath}/app-release-0426-14-59-42-mapping.txt"
//resource R.txt to build patch apk, must input if there is resource changed
tinkerApplyResourcePath = "${bakPath}/app-release-0426-14-59-42-R.txt"
//only use for build all flavor, if not, just ignore this field
tinkerBuildFlavorDirectory = "${bakPath}/app-0421-17-11-26"
}
def getOldApkPath() {
return hasProperty("OLD_APK") ? OLD_APK : ext.tinkerOldApkPath
}
def getApplyMappingPath() {
return hasProperty("APPLY_MAPPING") ? APPLY_MAPPING : ext.tinkerApplyMappingPath
}
def getApplyResourceMappingPath() {
return hasProperty("APPLY_RESOURCE") ? APPLY_RESOURCE : ext.tinkerApplyResourcePath
}
def getTinkerIdValue() {
return hasProperty("TINKER_ID") ? TINKER_ID : gitSha()
}
def buildWithTinker() {
return hasProperty("TINKER_ENABLE") ? TINKER_ENABLE : ext.tinkerEnabled
}
def getTinkerBuildFlavorDirectory() {
return ext.tinkerBuildFlavorDirectory
}
if (buildWithTinker()) {
apply plugin: 'com.tencent.tinker.patch'
tinkerPatch {
/**
* 默认为null
* 将旧的apk和新的apk建立关联
* 从build / bakApk添加apk
*/
oldApk = getOldApkPath()
/**
* 可选，默认'false'
*有些情况下我们可能会收到一些警告
*如果ignoreWarning为true，我们只是断言补丁过程
* case 1：minSdkVersion低于14，但是你使用dexMode与raw。
* case 2：在AndroidManifest.xml中新添加Android组件，
* case 3：装载器类在dex.loader {}不保留在主要的dex，
* 它必须让tinker不工作。
* case 4：在dex.loader {}中的loader类改变，
* 加载器类是加载补丁dex。改变它们是没有用的。
* 它不会崩溃，但这些更改不会影响。你可以忽略它
* case 5：resources.arsc已经改变，但是我们不使用applyResourceMapping来构建
*/
ignoreWarning = false
/**
*可选，默认为“true”
* 是否签名补丁文件
* 如果没有，你必须自己做。否则在补丁加载过程中无法检查成功
* 我们将使用sign配置与您的构建类型
*/
useSign = true
/**
可选，默认为“true”
是否使用tinker构建
*/
tinkerEnable = buildWithTinker()
/**
* 警告，applyMapping会影响正常的android build！
*/
buildConfig {
/**
*可选，默认为'null'
* 如果我们使用tinkerPatch构建补丁apk，你最好应用旧的
* apk映射文件如果minifyEnabled是启用！
* 警告：你必须小心，它会影响正常的组装构建！
*/
applyMapping = getApplyMappingPath()
/**
*可选，默认为'null'
* 很高兴保持资源ID从R.txt文件，以减少java更改
*/
applyResourceMapping = getApplyResourceMappingPath()
/**
*必需，默认'null'
* 因为我们不想检查基地apk与md5在运行时（它是慢）
* tinkerId用于在试图应用补丁时标识唯一的基本apk。
* 我们可以使用git rev，svn rev或者简单的versionCode。
* 我们将在您的清单中自动生成tinkerId
*/
tinkerId = getTinkerIdValue()
/**
*如果keepDexApply为true，则表示dex指向旧apk的类。
* 打开这可以减少dex diff文件大小。
*/
keepDexApply = false
}
dex {
/**
*可选，默认'jar'
* 只能是'raw'或'jar'。对于原始，我们将保持其原始格式
* 对于jar，我们将使用zip格式重新包装dexes。
* 如果你想支持下面14，你必须使用jar
* 或者你想保存rom或检查更快，你也可以使用原始模式
*/
dexMode = "jar"
/**
*必需，默认'[]'
* apk中的dexes应该处理tinkerPatch
* 它支持*或？模式。
*/
pattern = ["classes*.dex",
"assets/secondary-dex-?.jar"]
/**
*必需，默认'[]'
* 警告，这是非常非常重要的，加载类不能随补丁改变。
* 因此，它们将从补丁程序中删除。
* 你必须把下面的类放到主要的dex。
* 简单地说，你应该添加自己的应用程序{@code tinker.sample.android.SampleApplication}
* 自己的tinkerLoader，和你使用的类
*
*/
loader = [
//use sample, let BaseBuildInfo unchangeable with tinker
"tinker.sample.android.app.BaseBuildInfo"
]
}
lib {
/**
可选，默认'[]'
apk中的图书馆应该处理tinkerPatch
它支持*或？模式。
对于资源库，我们只是在补丁目录中恢复它们
你可以得到他们在TinkerLoadResult与Tinker
*/
pattern = ["lib/armeabi/*.so"]
}
res {
/**
*可选，默认'[]'
* apk中的什么资源应该处理tinkerPatch
* 它支持*或？模式。
* 你必须包括你在这里的所有资源，
* 否则，他们不会重新包装在新的apk资源。
*/
pattern = ["res/*", "assets/*", "resources.arsc", "AndroidManifest.xml"]
/**
*可选，默认'[]'
*资源文件排除模式，忽略添加，删除或修改资源更改
* *它支持*或？模式。
* *警告，我们只能使用文件没有relative与resources.arsc
*/
ignoreChange = ["assets/sample_meta.txt"]
/**
*默认100kb
* *对于修改资源，如果它大于'largeModSize'
* *我们想使用bsdiff算法来减少补丁文件的大小
*/
largeModSize = 100
}
packageConfig {
/**
*可选，默认'TINKER_ID，TINKER_ID_VALUE'，'NEW_TINKER_ID，NEW_TINKER_ID_VALUE'
* 包元文件gen。路径是修补程序文件中的assets / package_meta.txt
* 你可以在您自己的PackageCheck方法中使用securityCheck.getPackageProperties（）
* 或TinkerLoadResult.getPackageConfigByName
* 我们将从旧的apk清单为您自动获取TINKER_ID，
* 其他配置文件（如下面的patchMessage）不是必需的
*/
configField("patchMessage", "tinker is sample to use")
/**
*只是一个例子，你可以使用如sdkVersion，品牌，渠道...
* 你可以在SamplePatchListener中解析它。
* 然后你可以使用补丁条件！
*/
configField("platform", "all")
/**
* 补丁版本通过packageConfig
*/
configField("patchVersion", "1.0")
}
//或者您可以添加外部的配置文件，或从旧apk获取元值
//project.tinkerPatch.packageConfig.configField("test1", project.tinkerPatch.packageConfig.getMetaDataFromOldApk("Test"))
//project.tinkerPatch.packageConfig.configField("test2", "sample")
/**
* 如果你不使用zipArtifact或者path，我们只是使用7za来试试
*/
sevenZip {
/**
* 可选，默认'7za'
* 7zip工件路径，它将使用正确的7za与您的平台
*/
zipArtifact = "com.tencent.mm:SevenZip:1.1.10"
/**
* 可选，默认'7za'
* 你可以自己指定7za路径，它将覆盖zipArtifact值
*/
// path = "/usr/local/bin/7za"
}
}
List<String> flavors = new ArrayList<>();
project.android.productFlavors.each {flavor ->
flavors.add(flavor.name)
}
boolean hasFlavors = flavors.size() > 0
/**
* bak apk and mapping
*/
android.applicationVariants.all { variant ->
/**
* task type, you want to bak
*/
def taskName = variant.name
def date = new Date().format("MMdd-HH-mm-ss")
tasks.all {
if ("assemble${taskName.capitalize()}".equalsIgnoreCase(it.name)) {
it.doLast {
copy {
def fileNamePrefix = "${project.name}-${variant.baseName}"
def newFileNamePrefix = hasFlavors ? "${fileNamePrefix}" : "${fileNamePrefix}-${date}"
def destPath = hasFlavors ? file("${bakPath}/${project.name}-${date}/${variant.flavorName}") : bakPath
from variant.outputs[0].outputFile
into destPath
rename { String fileName ->
fileName.replace("${fileNamePrefix}.apk", "${newFileNamePrefix}.apk")
}
from "${buildDir}/outputs/mapping/${variant.dirName}/mapping.txt"
into destPath
rename { String fileName ->
fileName.replace("mapping.txt", "${newFileNamePrefix}-mapping.txt")
}
from "${buildDir}/intermediates/symbols/${variant.dirName}/R.txt"
into destPath
rename { String fileName ->
fileName.replace("R.txt", "${newFileNamePrefix}-R.txt")
}
}
}
}
}
}
project.afterEvaluate {
//sample use for build all flavor for one time
if (hasFlavors) {
task(tinkerPatchAllFlavorRelease) {
group = 'tinker'
def originOldPath = getTinkerBuildFlavorDirectory()
for (String flavor : flavors) {
def tinkerTask = tasks.getByName("tinkerPatch${flavor.capitalize()}Release")
dependsOn tinkerTask
def preAssembleTask = tasks.getByName("process${flavor.capitalize()}ReleaseManifest")
preAssembleTask.doFirst {
String flavorName = preAssembleTask.name.substring(7, 8).toLowerCase() + preAssembleTask.name.substring(8, preAssembleTask.name.length() - 15)
project.tinkerPatch.oldApk = "${originOldPath}/${flavorName}/${project.name}-${flavorName}-release.apk"
project.tinkerPatch.buildConfig.applyMapping = "${originOldPath}/${flavorName}/${project.name}-${flavorName}-release-mapping.txt"
project.tinkerPatch.buildConfig.applyResourceMapping = "${originOldPath}/${flavorName}/${project.name}-${flavorName}-release-R.txt"
}
}
}
task(tinkerPatchAllFlavorDebug) {
group = 'tinker'
def originOldPath = getTinkerBuildFlavorDirectory()
for (String flavor : flavors) {
def tinkerTask = tasks.getByName("tinkerPatch${flavor.capitalize()}Debug")
dependsOn tinkerTask
def preAssembleTask = tasks.getByName("process${flavor.capitalize()}DebugManifest")
preAssembleTask.doFirst {
String flavorName = preAssembleTask.name.substring(7, 8).toLowerCase() + preAssembleTask.name.substring(8, preAssembleTask.name.length() - 13)
project.tinkerPatch.oldApk = "${originOldPath}/${flavorName}/${project.name}-${flavorName}-debug.apk"
project.tinkerPatch.buildConfig.applyMapping = "${originOldPath}/${flavorName}/${project.name}-${flavorName}-debug-mapping.txt"
project.tinkerPatch.buildConfig.applyResourceMapping = "${originOldPath}/${flavorName}/${project.name}-${flavorName}-debug-R.txt"
}
}
}
}
}
}
三、修改application（具体代码地址）
Tinker的推荐写法：写一个类继承DefaultApplicationLike，自己的application的逻辑则写在onCreate()方法里面。下面的官方示例代码，注意这里@DefaultLifeCycle里面的SampleApplication的名字随意取，但是和androidManifest文件中application中name保持一致（如果显示红色，build一下），如下
@SuppressWarnings("unused")
@DefaultLifeCycle(application = "tinker.sample.android.app.SampleApplication",
flags = ShareConstants.TINKER_ENABLE_ALL,
loadVerifyFlag = false)
public class SampleApplicationLike extends DefaultApplicationLike {
private static final String TAG = "Tinker.SampleApplicationLike";
..............
..............
@Override
public void onCreate() {
super.onCreate();
//此处写自己的Application逻辑
}
<application
//和上面@DefaultLifeCycle里包名和类名一致
android:name=".app.SampleApplication"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:theme="@style/AppTheme">
.............
</application>
四、注册一个加载补丁回调结果的Service
service中所做的操作是在你加载成功热更新插件后，会提示你更新成功，并且这里做了锁屏操作就会加载热更新插件
package example.glh.tencenthotfix.service;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Handler;
import android.os.Looper;
import android.widget.Toast;
import com.tencent.tinker.lib.service.DefaultTinkerResultService;
import com.tencent.tinker.lib.service.PatchResult;
import com.tencent.tinker.lib.util.TinkerLog;
import com.tencent.tinker.lib.util.TinkerServiceInternals;
import com.tencent.tinker.loader.shareutil.SharePatchFileUtil;
import java.io.File;
import example.glh.tencenthotfix.utils.Utils;
/**
* optional, you can just use DefaultTinkerResultService
* we can restart process when we are at background or screen off
*/
public class SampleResultService extends DefaultTinkerResultService {
private static final String TAG = "Tinker.SampleResultService";
@Override
public void onPatchResult(final PatchResult result) {
if (result == null) {
TinkerLog.e(TAG, "SampleResultService received null result!!!!");
return;
}
TinkerLog.i(TAG, "SampleResultService receive result: %s", result.toString());
//first, we want to kill the recover process
TinkerServiceInternals.killTinkerPatchServiceProcess(getApplicationContext());
Handler handler = new Handler(Looper.getMainLooper());
handler.post(new Runnable() {
@Override
public void run() {
if (result.isSuccess) {
Toast.makeText(getApplicationContext(), "patch success, please restart process", Toast.LENGTH_LONG).show();
} else {
Toast.makeText(getApplicationContext(), "patch fail, please check reason", Toast.LENGTH_LONG).show();
}
}
});
// is success and newPatch, it is nice to delete the raw file, and restart at once
// for old patch, you can't delete the patch file
if (result.isSuccess) {
File rawFile = new File(result.rawPatchFilePath);
if (rawFile.exists()) {
TinkerLog.i(TAG, "save delete raw patch file");
SharePatchFileUtil.safeDeleteFile(rawFile);
}
//not like TinkerResultService, I want to restart just when I am at background!
//if you have not install tinker this moment, you can use TinkerApplicationHelper api
if (checkIfNeedKill(result)) {
if (Utils.isBackground()) {
TinkerLog.i(TAG, "it is in background, just restart process");
restartProcess();
} else {
//we can wait process at background, such as onAppBackground
//or we can restart when the screen off
TinkerLog.i(TAG, "tinker wait screen to restart process");
new ScreenState(getApplicationContext(), new ScreenState.IOnScreenOff() {
@Override
public void onScreenOff() {
restartProcess();
}
});
}
} else {
TinkerLog.i(TAG, "I have already install the newly patch version!");
}
}
}
/**
* you can restart your process through service or broadcast
*/
private void restartProcess() {
TinkerLog.i(TAG, "app is background now, i can kill quietly");
//you can send service or broadcast intent to restart your process
android.os.Process.killProcess(android.os.Process.myPid());
}
static class ScreenState {
interface IOnScreenOff {
void onScreenOff();
}
ScreenState(Context context, final IOnScreenOff onScreenOffInterface) {
IntentFilter filter = new IntentFilter();
filter.addAction(Intent.ACTION_SCREEN_OFF);
context.registerReceiver(new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent in) {
String action = in == null ? "" : in.getAction();
TinkerLog.i(TAG, "ScreenReceiver action [%s] ", action);
if (Intent.ACTION_SCREEN_OFF.equals(action)) {
context.unregisterReceiver(this);
if (onScreenOffInterface != null) {
onScreenOffInterface.onScreenOff();
}
}
}
}, filter);
}
}
}
五、Utils工具类
package example.glh.tencenthotfix.utils;
import android.os.Environment;
import android.os.StatFs;
import com.tencent.tinker.loader.shareutil.ShareConstants;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.PrintStream;
/**
* created by yezhengyu on 2019/4/25 13:56
*/
public class Utils {
/**
* the error code define by myself
* should after {@code ShareConstants.ERROR_PATCH_INSERVICE
*/
public static final int ERROR_PATCH_GOOGLEPLAY_CHANNEL = -5;
public static final int ERROR_PATCH_ROM_SPACE = -6;
public static final int ERROR_PATCH_MEMORY_LIMIT = -7;
public static final int ERROR_PATCH_ALREADY_APPLY = -8;
public static final int ERROR_PATCH_CRASH_LIMIT = -9;
public static final int ERROR_PATCH_RETRY_COUNT_LIMIT = -10;
public static final int ERROR_PATCH_CONDITION_NOT_SATISFIED = -11;
public static final String PLATFORM = "platform";
public static final int MIN_MEMORY_HEAP_SIZE = 45;
private static boolean background = false;
public static boolean isGooglePlay() {
return false;
}
public static boolean isBackground() {
return background;
}
public static void setBackground(boolean back) {
background = back;
}
public static int checkForPatchRecover(long roomSize, int maxMemory) {
if (Utils.isGooglePlay()) {
return Utils.ERROR_PATCH_GOOGLEPLAY_CHANNEL;
}
if (maxMemory < MIN_MEMORY_HEAP_SIZE) {
return Utils.ERROR_PATCH_MEMORY_LIMIT;
}
//or you can mention user to clean their rom space!
if (!checkRomSpaceEnough(roomSize)) {
return Utils.ERROR_PATCH_ROM_SPACE;
}
return ShareConstants.ERROR_PATCH_OK;
}
public static boolean isXposedExists(Throwable thr) {
StackTraceElement[] stackTraces = thr.getStackTrace();
for (StackTraceElement stackTrace : stackTraces) {
final String clazzName = stackTrace.getClassName();
if (clazzName != null && clazzName.contains("de.robv.android.xposed.XposedBridge")) {
return true;
}
}
return false;
}
@Deprecated
public static boolean checkRomSpaceEnough(long limitSize) {
long allSize;
long availableSize = 0;
try {
File data = Environment.getDataDirectory();
StatFs sf = new StatFs(data.getPath());
availableSize = (long) sf.getAvailableBlocks() * (long) sf.getBlockSize();
allSize = (long) sf.getBlockCount() * (long) sf.getBlockSize();
} catch (Exception e) {
allSize = 0;
}
if (allSize != 0 && availableSize > limitSize) {
return true;
}
return false;
}
public static String getExceptionCauseString(final Throwable ex) {
final ByteArrayOutputStream bos = new ByteArrayOutputStream();
final PrintStream ps = new PrintStream(bos);
try {
// print directly
Throwable t = ex;
while (t.getCause() != null) {
t = t.getCause();
}
t.printStackTrace(ps);
return toVisualString(bos.toString());
} finally {
try {
bos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
private static String toVisualString(String src) {
boolean cutFlg = false;
if (null == src) {
return null;
}
char[] chr = src.toCharArray();
if (null == chr) {
return null;
}
int i = 0;
for (; i < chr.length; i++) {
if (chr[i] > 127) {
chr[i] = 0;
cutFlg = true;
break;
}
}
if (cutFlg) {
return new String(chr, 0, i);
} else {
return src;
}
}
}
六、注册SampleResultService，添加访问sd卡权限
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="example.glh.tencenthotfix">
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
.........
.........
<service
android:name=".service.SampleResultService"
android:exported="false" />
</application>
</manifest>
七、在MainActivity中添加按钮调用Tinker的api，测试实际效果（包含访问android6.0以上sd权限）
package example.glh.tencenthotfix;
import android.Manifest;
import android.content.pm.PackageManager;
import android.os.Environment;
import android.support.v4.app.ActivityCompat;
import android.support.v4.content.ContextCompat;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import com.tencent.tinker.lib.tinker.TinkerInstaller;
import com.tencent.tinker.loader.shareutil.ShareTinkerInternals;
import example.glh.tencenthotfix.utils.Utils;
public class MainActivity extends AppCompatActivity implements View.OnClickListener {
private static final int MY_PERMISSIONS_REQUEST_CALL_PHONE = 2;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
findViewById(R.id.button1).setOnClickListener(this);
findViewById(R.id.button2).setOnClickListener(this);
}
@Override
protected void onResume() {
super.onResume();
//判断存储权限，如果没有就申请，用户拒绝就提示某些功能不可用
setPermission();
Utils.setBackground(false);
}
@Override
protected void onPause() {
super.onPause();
Utils.setBackground(true);
}
@Override
public void onClick(View v) {
switch (v.getId()){
case R.id.button1:
loadPatch();
break;
case R.id.button2:
killApp();
break;
}
}
/**
* 加载热补丁插件
*/
public void loadPatch() {
TinkerInstaller.onReceiveUpgradePatch(getApplicationContext(),
Environment.getExternalStorageDirectory().getAbsolutePath() + "/patch_signed_7zip.apk");
}
/**
* 杀死应用加载补丁
*/
public void killApp() {
ShareTinkerInternals.killAllOtherProcess(getApplicationContext());
android.os.Process.killProcess(android.os.Process.myPid());
}
private void setPermission() {
if (ContextCompat.checkSelfPermission(this,
Manifest.permission.WRITE_EXTERNAL_STORAGE)
!= PackageManager.PERMISSION_GRANTED) {
ActivityCompat.requestPermissions(this,
new String[]{Manifest.permission.READ_EXTERNAL_STORAGE,
Manifest.permission.WRITE_EXTERNAL_STORAGE,
Manifest.permission.CAMERA
}, MY_PERMISSIONS_REQUEST_CALL_PHONE);
}
}
@Override
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
if (requestCode == MY_PERMISSIONS_REQUEST_CALL_PHONE) {
if (grantResults[0] == PackageManager.PERMISSION_GRANTED) {
//获取到存储权限
} else {
// Permission Denied
//拒绝了权限
//AppContext.showToastText(getResources().getString(R.string.denied_permission));
//AppContext.showToast(R.string.denied_permission);
}
return;
}
super.onRequestPermissionsResult(requestCode, permissions, grantResults);
}
}
Tinker的接入操作已经完成了，接下来我们进行测试工作
第二部分，Tinker的测试
我们需要的实际效果是，在不需要从新打包安装的情况下将补丁加载进来，点击加载补丁，然后杀死进程或关掉屏幕，再次进入App之后效果如下（加载补丁前后我们只在布局中做一些改变，这样更容易观察）
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7UkmQAbr-1611192879165)(
)][外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9wriEG6d-1611192879167)(
)]
一、打加载补丁前的包
打开Android Studio的Gradle 界面，双击 assembleDebug 或者 assembleRelease：
二、之后在build的bakApk目录下生成apk和R文件，双击assembleRelease会生成mapping文件
将apk安装到手机之后，是加载补丁前的效果
三、打补丁包
- 我们先将一种生成的apk和R或mapping文件的文件名复制到app的gradle中ext下，替换之前的名称，并Sync Now一下
2. 修改主界面，增加TextView和ImageView
3. 打补丁包，还是在gradle界面，双击tinker下tinkerPatchDebug 或者tinkerPatchRelease
4. 在build文件目录下，patch_signed_7zip.apk就是我们所需要的补丁包，将其拷贝到手机的sdcard的根目录中
5. 在MainActivity中点击加载补丁按钮路径和上面sd卡根路径保持一致。实际项目中补丁包应该是给后台，然后通过下载到手机的sd卡或其他路径下的
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
findViewById(R.id.button1).setOnClickListener(this);
findViewById(R.id.button2).setOnClickListener(this);
}
...........
..........
/**
* 加载热补丁插件
*/
public void loadPatch() {
TinkerInstaller.onReceiveUpgradePatch(getApplicationContext(),
Environment.getExternalStorageDirectory().getAbsolutePath() + "/patch_signed_7zip.apk");
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
