Android开发之玩转 Gradle，你可不能不熟悉 Transform

最新推荐文章于 2024-10-31 14:07:55 发布

2401_84008985

最新推荐文章于 2024-10-31 14:07:55 发布

阅读量775

点赞数 8

分类专栏：程序员文章标签： android python pycharm

本文链接：https://blog.csdn.net/2401_84008985/article/details/137176979

版权

程序员专栏收录该内容

270 篇文章 3 订阅

订阅专栏

@Override

public void createTasksForVariantScope(@NonNull final VariantScope variantScope) {

…

// ----- External Transforms -----

// apply all the external transforms.

List customTransforms = extension.getTransforms();

List<List> customTransformsDependencies = extension.getTransformsDependencies();

for (int i = 0, count = customTransforms.size(); i < count; i++) {

Transform transform = customTransforms.get(i);

// Check the transform only applies to supported scopes for libraries:

// We cannot transform scopes that are not packaged in the library

// itself.

Sets.SetView<? super Scope> difference =

Sets.difference(transform.getScopes(), TransformManager.PROJECT_ONLY);

if (!difference.isEmpty()) {

String scopes = difference.toString();

globalScope

.getAndroidBuilder()

.getIssueReporter()

.reportError(

Type.GENERIC,

new EvalIssueException(

String.format(

“Transforms with scopes ‘%s’ cannot be applied to library projects.”,

scopes)));

}

List deps = customTransformsDependencies.get(i);

transformManager.addTransform(

taskFactory,

variantScope,

transform,

null,

task -> {

if (!deps.isEmpty()) {

task.dependsOn(deps);

}

taskProvider -> {

// if the task is a no-op then we make assemble task

// depend on it.

if (transform.getScopes().isEmpty()) {

TaskFactoryUtils.dependsOn(

variantScope.getTaskContainer().getAssembleTask(),

taskProvider);

}

});

}

// Now add transforms for intermediate publishing (projects to projects).

File jarOutputFolder = variantScope.getIntermediateJarOutputFolder();

File mainClassJar = new File(jarOutputFolder, FN_CLASSES_JAR);

File mainResJar = new File(jarOutputFolder, FN_INTERMEDIATE_RES_JAR);

LibraryIntermediateJarsTransform intermediateTransform =

new LibraryIntermediateJarsTransform(

mainClassJar,

mainResJar,

variantConfig::getPackageFromManifest,

extension.getPackageBuildConfig());

excludeDataBindingClassesIfNecessary(variantScope, intermediateTransform);

BuildArtifactsHolder artifacts = variantScope.getArtifacts();

transformManager.addTransform(

taskFactory,

variantScope,

intermediateTransform,

taskName -> {

// publish the intermediate classes.jar

artifacts.appendArtifact(

InternalArtifactType.LIBRARY_CLASSES,

ImmutableList.of(mainClassJar),

taskName);

// publish the res jar

artifacts.appendArtifact(

InternalArtifactType.LIBRARY_JAVA_RES,

ImmutableList.of(mainResJar),

taskName);

null,

null);

taskFactory.register(new LibraryDexingTask.CreationAction(variantScope));

// Create a jar with both classes and java resources. This artifact is not

// used by the Android application plugin and the task usually don’t need to

// be executed. The artifact is useful for other Gradle users who needs the

// ‘jar’ artifact as API dependency.

taskFactory.register(new ZipMergingTask.CreationAction(variantScope));

// now add a transform that will take all the native libs and package

// them into an intermediary folder. This processes only the PROJECT

// scope.

final File intermediateJniLibsFolder = new File(jarOutputFolder, FD_JNI);

LibraryJniLibsTransform intermediateJniTransform =

new LibraryJniLibsTransform(

“intermediateJniLibs”,

intermediateJniLibsFolder,

TransformManager.PROJECT_ONLY);

transformManager.addTransform(

taskFactory,

variantScope,

intermediateJniTransform,

taskName -> {

// publish the jni folder as intermediate

variantScope

.getArtifacts()

.appendArtifact(

InternalArtifactType.LIBRARY_JNI,

ImmutableList.of(intermediateJniLibsFolder),

taskName);

null,

null);

// Now go back to fill the pipeline with transforms used when

// publishing the AAR

// first merge the resources. This takes the PROJECT and LOCAL_DEPS

// and merges them together.

createMergeJavaResTransform(variantScope);

// ----- Minify next -----

maybeCreateJavaCodeShrinkerTransform(variantScope);

maybeCreateResourcesShrinkerTransform(variantScope);

// now add a transform that will take all the class/res and package them

// into the main and secondary jar files that goes in the AAR.

// This transform technically does not use its transform output, but that’s

// ok. We use the transform mechanism to get incremental data from

// the streams.

// This is used for building the AAR.

File classesJar = variantScope.getAarClassesJar();

File libsDirectory = variantScope.getAarLibsDirectory();

LibraryAarJarsTransform transform =

new LibraryAarJarsTransform(

classesJar,

libsDirectory,

artifacts.hasArtifact(InternalArtifactType.ANNOTATIONS_TYPEDEF_FILE)

? artifacts.getFinalArtifactFiles(

InternalArtifactType.ANNOTATIONS_TYPEDEF_FILE)

null,

variantConfig::getPackageFromManifest,

extension.getPackageBuildConfig());

excludeDataBindingClassesIfNecessary(variantScope, transform);

transformManager.addTransform(

taskFactory,

variantScope,

transform,

taskName -> {

variantScope

.getArtifacts()

.appendArtifact(

InternalArtifactType.AAR_MAIN_JAR,

ImmutableList.of(classesJar),

taskName);

variantScope

.getArtifacts()

.appendArtifact(

InternalArtifactType.AAR_LIBS_DIRECTORY,

ImmutableList.of(libsDirectory),

taskName);

null,

null);

// now add a transform that will take all the native libs and package

// them into the libs folder of the bundle. This processes both the PROJECT

// and the LOCAL_PROJECT scopes

final File jniLibsFolder =

variantScope.getIntermediateDir(InternalArtifactType.LIBRARY_AND_LOCAL_JARS_JNI);

LibraryJniLibsTransform jniTransform =

new LibraryJniLibsTransform(

“syncJniLibs”,

jniLibsFolder,

TransformManager.SCOPE_FULL_LIBRARY_WITH_LOCAL_JARS);

transformManager.addTransform(

taskFactory,

variantScope,

jniTransform,

taskName ->

variantScope

.getArtifacts()

.appendArtifact(

InternalArtifactType.LIBRARY_AND_LOCAL_JARS_JNI,

ImmutableList.of(jniLibsFolder),

taskName),

null,

null);

createLintTasks(variantScope);

createBundleTask(variantScope);

}

自定义Transform和其他系统Transform执行的顺序

而且上述方法我们可以看出，任务还是会根据DAG（有向无环图）生成Task，其中会包含一些系统的Transform，其顺序有可能会被插入到自定义的Transform之前，而有一些则会被放置在所有的Tranform执行之后。比如LibraryJniLibsTransform。
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则近万的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。