Artículos publicados anteriormente: Cargue APK en Dandelion en el complemento personalizado de Gradle . Háganos saber algunas de las características del complemento personalizado.
En términos generales, al lanzar, nuestro APK necesita ser fortalecido, después de todo, es más seguro. Aquí, combinamos los complementos anteriores para definir una tarea de endurecimiento de APK. Entonces, vamos a automatizar un poco más. Pack –→ Reforzar –→ Subir Diente de León .
Dado que es una implementación automatizada, no debemos usar herramientas de operación de endurecimiento gráfico.
Pasos:
- 1. El siguiente paquete reforzado
- 2. Crear una tarea Tarea reforzada
- 3. Modificar la extensión extensión del complemento
- 4. Modifique la ruta apk de la tarea de carga
- 5. Modificar las dependencias de nuestro plug-in para que pueda ser empaquetado-→reforzado-→subir dandelion
- 6. Convocatoria de proyecto
1. Descargar 360 Seguridad Reforzada
Dado que se está endureciendo, en primer lugar, debemos registrarnos en el sitio web oficial de 360 y descargar la protección de endurecimiento: sitio web oficial (el endurecimiento de Tencent no parece admitir la carga local de APK).
Descomprimir directorio
Aquí, debemos ejecutar jiagu.jar a través de la línea de comando para completar nuestro endurecimiento automático de apk.
Hay algunos comandos reforzados en help.txt, si está interesado, puede probarlos todos.
Con el refuerzo 360, es hora de empezar a escribir nuestra tarea de refuerzo.
2. Crear una tarea Tarea reforzada
La creación de la tarea de refuerzo es lo mismo que subir la tarea, hereda la DefaultTask, y luego, al anotar @TaskAction en el método, se ejecuta nuestra tarea.
Para crear una tarea de refuerzo, principalmente hacemos lo siguiente:
- 1. Configure un grupo para nuestra tarea de refuerzo y colóquelo en el mismo grupo que la tarea de carga.
- 2. Cree una clase de modelo para almacenar algunos parámetros necesarios para el endurecimiento.
Por ejemplo, el archivo del paquete jar endurecido, la contraseña de la cuenta, la información de la firma, el apk antes del endurecimiento, la ruta después del endurecimiento, etc. - 3. Al realizar el endurecimiento, obtenga la información del parámetro de la clase Modelo
- 4. Ejecute los comandos necesarios para el refuerzo 360
, como iniciar sesión, importar firma, refuerzo, establecer firma automática, etc.
public class ReinforceTask extends DefaultTask {
private BaseVariant mVariant;
private Project mTargetProject;
//加固相关的信息
public static class ReinforceModel {
//加固包的位置(jiagu.jar) 及登录账号密码
public File reinforceJarFile;
public String reinforceUsername;
public String reinforcePassword;
//签名文件 密码等信息
public File signStoreFile;
public String signPassword;
public String signKeyAlias;
public String signKeyPassword;
//打包apk路径及加固后apk的路径
public File inputApkFile;
public File outputApkFile;
}
public void init(BaseVariant variant, Project project) {
this.mVariant = variant;
this.mTargetProject = project;
setDescription("reinforce for apk");
setGroup(TestJavaPlugin.PLUGIN_EXTENSION_NAME);
}
@TaskAction
public void reinforceApk() {
System.out.println("==============start JiaGu");
ReinforceModel request = initReinforceModel();
String loginCmdData = "java -jar %s -login %s %s";
String loginExec = String
.format(loginCmdData, request.reinforceJarFile, request.reinforceUsername,
request.reinforcePassword);
String loginMessage = exec(loginExec);
System.out.println("==========exe JiaGu Result: " + loginMessage);
String signCmdData = "java -jar %s -importsign %s %s %s %s";
String signExec = String
.format(signCmdData, request.reinforceJarFile, request.signStoreFile,
request.signPassword,
request.signKeyAlias, request.signKeyPassword);
//导入签名
String signResult = exec(signExec);
System.out.println("===========exe JiaGu Sign Result: " + signResult);
//自动签名
String suffixCmd = " -autosign ";
if (!request.outputApkFile.exists()) {
request.outputApkFile.mkdirs();
}
//jiagu.jar ,input apk file path, output apk dir
String reinforceCmdData = "java -jar %s -jiagu %s %s";
String reinforceExec = String
.format(reinforceCmdData, request.reinforceJarFile, request.inputApkFile,
request.outputApkFile);
//reinforce
String jiaguResult = exec(reinforceExec + suffixCmd);
System.out.println("=========exe APK JiaGu Result : " + jiaguResult);
}
@NotNull
private ReinforceModel initReinforceModel() {
Extension extension = Extension.getConfig(mTargetProject);
ReinforceModel request = new ReinforceModel();
request.outputApkFile = extension.outputFile;
request.reinforceJarFile = extension.reinforceJarFile;
request.reinforceUsername = extension.reinforceUsername;
request.reinforcePassword = extension.reinforcePassword;
NamedDomainObjectContainer<SigningConfig> signingConfigs = ((AppExtension) mTargetProject
.getExtensions().findByName(TestJavaPlugin.ANDROID_EXTENSION_NAME)).getSigningConfigs();
if (signingConfigs == null) {
throw new IllegalArgumentException("please config your sign info.");
}
for (SigningConfig config : signingConfigs) {
request.signStoreFile = config.getStoreFile();
request.signPassword = config.getStorePassword();
request.signKeyAlias = config.getKeyAlias();
request.signKeyPassword = config.getKeyPassword();
}
for (BaseVariantOutput output : mVariant.getOutputs()) {
request.inputApkFile = output.getOutputFile();
if (request.inputApkFile == null || !request.inputApkFile.exists()) {
throw new GradleException("apk file is not exist!");
}
}
if (request.signStoreFile == null || !request.signStoreFile.exists()) {
throw new IllegalArgumentException("please config your sign info.");
}
return request;
}
private String exec(String command) {
StringBuilder resultBuilder = new StringBuilder();
Process pro = null;
BufferedReader input = null;
Runtime runTime = Runtime.getRuntime();
if (runTime == null) {
throw new NullPointerException("reinforce task failed,Runtime is null");
}
try {
pro = runTime.exec(command);
input = new BufferedReader(new InputStreamReader(pro.getInputStream()));
String line;
while ((line = input.readLine()) != null) {
resultBuilder.append(line).append("\n");
}
} catch (IOException ex) {
ex.printStackTrace();
} finally {
if (pro != null) {
pro.destroy();
}
if (input != null) {
try {
input.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return resultBuilder.toString();
}
}
Aquí vemos:
1. Utilice ReinforceModel para guardar la información de parámetros necesaria para el refuerzo.
2. Configure el grupo
3 en el método de inicialización init(), y en el método initReinforceModel(), obtenga el número de cuenta, la firma y otra información que necesitamos para el refuerzo.
4. A través del método reforzadoApk() se ejecutarán los comandos de inicio de sesión, importar firma, refuerzo y firma automática respectivamente.
En este punto, nuestra tarea de endurecimiento personalizado está completa.
A continuación, combinaremos la carga automática anterior a Dandelion Task para realizar el proceso de empaquetado-refuerzo-carga.
3. Modificar la extensión extensión del complemento
Para completar el proceso de empaquetado, endurecimiento y carga, debemos modificar la clase Extension del artículo anterior y agregar los parámetros necesarios para el endurecimiento 360 para garantizar que podamos completar la tarea de endurecimiento.
public class Extension {
public String uKey;
public String apiKey;
public String appName;
//==========加固相关的信息
//指向加固的jar包
public File reinforceJarFile;
//登陆用户名
public String reinforceUsername;
//登陆密码
public String reinforcePassword;
//输出apk的目录
public File outputFile;
public Extension() {
}
public Extension(String uKey, String apiKey, String appName, File reinforceJarFile,
String reinforceUsername, String reinforcePassword, File outputFile) {
this.uKey = uKey;
this.apiKey = apiKey;
this.appName = appName;
this.reinforceJarFile = reinforceJarFile;
this.reinforceUsername = reinforceUsername;
this.reinforcePassword = reinforcePassword;
this.outputFile = outputFile;
}
public Extension(String appName, String uKey, String apiKey) {
this.uKey = uKey;
this.apiKey = apiKey;
this.appName = appName;
}
public static Extension getConfig(Project project) {
Extension extension = project.getExtensions().findByType(Extension.class);
if (extension == null) {
extension = new Extension();
}
return extension;
}
}
Aquí, vemos que solo agregamos el archivo del paquete jar endurecido, el nombre de usuario, la contraseña y la ruta de apk endurecida, y no agregamos información de firma, etc. Esto se debe a que podemos obtener estos parámetros a través de la expansión del sistema.
Agregar la ruta de apk endurecida es para modificar el paquete endurecido cuando se cargue a Dandelion más tarde. De lo contrario, el paquete cargado sigue siendo el paquete antes de que lo endurezcamos.
4. Modifique la ruta apk de la tarea de carga
La tarea cargada anteriormente es la ruta de empaquetado del sistema obtenida directamente. Necesitamos modificarlo a la ruta apk ingresada después del endurecimiento.
public class PGYUploadTask extends DefaultTask {
private BaseVariant mVariant;
private Project mTargetProject;
public static class PGYRequest {
public String uKey;
public String apiKey;
//1,install by public 2,install by password 3,install by invite
public String installType;
}
public void init(BaseVariant variant, Project project) {
this.mVariant = variant;
this.mTargetProject = project;
setDescription("upload to pgy");
setGroup(TestJavaPlugin.PLUGIN_EXTENSION_NAME);
}
@TaskAction
public void uploadToPGY() {
Extension extension = Extension.getConfig(mTargetProject);
PGYRequest request = new PGYRequest();
request.apiKey = extension.apiKey;
request.uKey = extension.uKey;
File apkDir = extension.outputFile;
if (apkDir == null || !apkDir.exists()) {
upload(request);
} else {
File[] files = apkDir.listFiles();
if (files != null && files.length > 0) {
upload(request.uKey, request.apiKey, files[0]);
}else{
upload(request);
}
}
// for (BaseVariantOutput output : mVariant.getOutputs()) {
// File file = output.getOutputFile();
// if (file == null || !file.exists()) {
// throw new GradleException("apk file is not exist!");
// }
// Extension extension = Extension.getConfig(mTargetProject);
//
// PGYRequest request = new PGYRequest();
// request.apiKey = extension.apiKey;
// request.uKey = extension.uKey;
// upload(request.uKey, request.apiKey, file);
// }
}
private void upload(PGYRequest request) {
for (BaseVariantOutput output : mVariant.getOutputs()) {
File file = output.getOutputFile();
if (file == null || !file.exists()) {
throw new GradleException("apk file is not exist!");
}
upload(request.uKey, request.apiKey, file);
}
}
private void upload(String ukey, String apiKey, File apkFile) {
//builder
MultipartBody.Builder bodyBuilder = new MultipartBody.Builder().setType(MultipartBody.FORM);
//add part
bodyBuilder.addFormDataPart("uKey", ukey);
bodyBuilder.addFormDataPart("_api_key", apiKey);
//add file
bodyBuilder.addFormDataPart("file", apkFile.getName(), RequestBody
.create(MediaType.parse("*/*"), apkFile));
//request
Request request = new Request.Builder()
.url("http://upload.pgyer.com/apiv1/app/upload")
.post(bodyBuilder.build())
.build();
OkHttpClient client = new OkHttpClient();
try {
Response response = client.newCall(request).execute();
String result = response.body().string();
System.out.println("upload result: " + result);
} catch (IOException e) {
e.printStackTrace();
} catch (Exception e) {
}
}
}
Aquí seleccionamos un apk para cargar de acuerdo con la ruta de apk reforzada definida en la Extensión (360 admite paquetes multicanal).
Para otro contenido, si no lo entiende, puede leer el Complemento personalizado de Gradle y cargar APK a Dandelion
Finalmente hemos completado la modificación de las dependencias de la tarea, y nuestro proceso es empaquetado-endurecimiento-carga.
5. Modificar las dependencias del complemento
Aquí, solo necesitamos modificar las dependencias de las tareas en el complemento.
public class TestJavaPlugin implements Plugin<Project> {
public static final String PLUGIN_EXTENSION_NAME = "uploadHelperJava";
public static final String ANDROID_EXTENSION_NAME = "android";
@Override
public void apply(Project project) {
Extension customExtension = project.getExtensions().create(PLUGIN_EXTENSION_NAME, Extension.class);
// project.getExtensions().create(PLUGIN_EXTENSION_NAME, Extension.class, project);
//项目编译完成后，回调
project.afterEvaluate(new Action<Project>() {
@Override
public void execute(Project project) {
DomainObjectSet<ApplicationVariant> appVariants = ((AppExtension) project
.getExtensions().findByName(ANDROID_EXTENSION_NAME)).getApplicationVariants();
for (ApplicationVariant variant : appVariants) {
//release apk
if (variant.getBuildType().getName().equalsIgnoreCase("uploadRelease") ) {
String variantName =
variant.getName().substring(0, 1).toUpperCase() + variant.getName().substring(1);
PGYUploadTask uploadTask = project.getTasks()
.create("uploadJavaFor" + variantName, PGYUploadTask.class);
uploadTask.init(variant, project);
ReinforceTask reinforceTask = project.getTasks()
.create("reinforceFor" + variantName, ReinforceTask.class);
reinforceTask.init(variant,project);
//依赖关系
variant.getAssembleProvider().get().dependsOn(project.getTasks().findByName("clean"));
reinforceTask.dependsOn(variant.getAssembleProvider().get());
uploadTask.dependsOn(reinforceTask);
}
}
}
});
}
}
Dejamos que la dependencia de la tarea reforzada empaquete la tarea, y luego cargamos la dependencia de la tarea para reforzar la tarea. De esta manera, todo nuestro proceso se completa. limpiar—empaquetar—endurecer—cargar.
6. Convocatoria de proyecto
Aquí, principalmente se publican complementos, se copia el paquete de refuerzo en el proyecto y luego se hace referencia al complemento, se completan los parámetros y se realizan llamadas.
1. Primero, volvemos a publicar nuestro complemento
Haga clic en cargar archivos en alone_plugin.
2. Para los elementos que se utilizarán, introduzca la protección de refuerzo 360
Copiamos los archivos descomprimidos del refuerzo a la carpeta libs del proyecto (el nombre del archivo es opcional, solo apúntelo al configurar el archivo de refuerzoJar)
Aquí, todos nuestros comandos de endurecimiento se realizan a través de jiagu.jar.
Los comandos de parámetros están todos en help.txt, así que no los presentaré aquí.
3. El build.gradle bajo el proyecto introduce el complemento
Introducción al proyecto de prueba, nuestro complemento de carga reforzado
buildscript {
repositories {
google()
jcenter()
maven{
url uri('./repo/')
}
}
dependencies {
classpath 'com.android.tools.build:gradle:3.3.1'
classpath 'com.liu.alone.plugin:java-plugin:1.0.0'
}
}
allprojects {
repositories {
google()
jcenter()
}
}
task clean(type: Delete) {
delete rootProject.buildDir
}
4. El módulo de la aplicación presenta el complemento.
appbuild.gradle
android {
...
signingConfigs {
release {
storeFile file('xxx.jks')
storePassword "xxx"
keyAlias "xxx"
keyPassword "xxx"
}
}
buildTypes {
release {
minifyEnabled false
signingConfig signingConfigs.release
proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
}
uploadRelease {
minifyEnabled false
signingConfig signingConfigs.release
proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
}
}
}
...
apply plugin: 'com.liu.alone.plugin'
uploadHelperJava {
appName = "testGradle"
uKey = "c9d2625c0cf221d8f4a98738f4c05e9a"
apiKey = "fac8875534d045a2be3f229abd46cc3e"
//加固相关的信息
reinforceJarFile = file("../libs/jiagu.jar")
reinforceUsername = "xxx"
reinforcePassword = "xxx"
outputFile = file("${buildDir.getAbsolutePath()}\\jiagu")
}
Consulte el complemento que escribimos y la información de parámetros requerida para el refuerzo de carga de configuración, etc.
refuerzoJarFile Este archivo de refuerzo apunta a jiagu.jar en libs. Si el refuerzo está guardado en otro directorio, se puede modificar aquí.
5. Finalmente llama a la tarea
Ejecute el uploadJavaForUploadRelease de la tarea Tareas en Gradle, la tarea que definimos.
resultado de impresión
任务完成_已签名
> Task :app:uploadJavaForUploadRelease
upload result: {"code":0,"message":"","data":{"appKey":"bb2b8b14f405d9024b0e18954beaadb8","userKey":"c9d2625c0cf221d8f4a98738f4c05e9a","appType":"2","appIsLastest":"2","appFileSize":"2206305","appName":"ObjectAnimatorTest","appVersion":"1.0","appVersionNo":"1","appBuildVersion":"9","appIdentifier":"com.liu.objectanimatortest","appIcon":"825df8e761ed960f5c3237e9af332df7","appDescription":"","appUpdateDescription":"","appScreenshots":"","appShortcutUrl":"t6rG","appCreated":"2020-01-02 11:19:53","appUpdated":"2020-01-02 11:19:53","appQRCodeURL":"http:\/\/www.pgyer.com\/app\/qrcodeHistory\/5dea8789700159c1d2804374dc80293b2e3f5e5ffd53531b777cfc4a33843c29"}}
Imprima el registro y vea que la firma se completa primero, luego se ejecuta la tarea de carga y, finalmente, se devuelve el resultado de la carga
otro
1. Complemento build.gradle
apply plugin: 'java-library'
apply plugin: 'maven'
dependencies {
compile gradleApi()
compile localGroovy()
compile 'com.android.tools.build:gradle:3.3.1'
implementation("com.squareup.okhttp3:okhttp:3.8.1")
}
repositories {
mavenCentral()
}
group = 'com.liu.alone.plugin'
version = '1.0.0'
archivesBaseName = 'java-plugin'
//upload
uploadArchives {
repositories {
mavenDeployer {
repository(url: uri('../repo'))
}
}
}
Hay principalmente bibliotecas de dependencia de Java, bibliotecas de carga okhttp y contenido publicado por complementos.
2. La estructura general del complemento
Principalmente build.gradle, archivo de propiedades, una clase de complemento, 2 clases de tareas y una clase de propiedad extendida.
En este punto, nuestro proceso: empaquetado – fortalecimiento – carga está completo.
Si no necesitamos necesariamente un refuerzo antes de cargar, ¿podemos definir una variable en la Extensión para controlarlo?, solo necesitamos modificar las dependencias del complemento y cargar la ruta de carga del apk de la Tarea.