[移动开发]Android开发之玩转 Gradle，你可不能不熟悉 Transform，三面美团Android岗

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

《Android学习笔记总结+最新移动架构视频+大厂安卓面试真题+项目实战源码讲义》

【docs.qq.com/doc/DSkNLaERkbnFoS0ZF】 完整内容开源分享

::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。

Transform和Task的关系

从这部分源代码其实我们就可以看出，我们注册到AppExtension里面的Transform,最后会createTasksForVariantScope方法调用到。

@NonNull

public Optional<TaskProvider> addTransform(

@NonNull TaskFactory taskFactory,

@NonNull TransformVariantScope scope,

@NonNull T transform,

@Nullable PreConfigAction preConfigAction,

@Nullable TaskConfigAction configAction,

@Nullable TaskProviderCallback providerCallback) {

if (!validateTransform(transform)) {

// validate either throws an exception, or records the problem during sync

// so it’s safe to just return null here.

return Optional.empty();

}

List inputStreams = Lists.newArrayList();

String taskName = scope.getTaskName(getTaskNamePrefix(transform));

// get referenced-only streams

List referencedStreams = grabReferencedStreams(transform);

// find input streams, and compute output streams for the transform.

IntermediateStream outputStream = findTransformStreams(

transform,

scope,

inputStreams,

taskName,

scope.getGlobalScope().getBuildDir());

if (inputStreams.isEmpty() && referencedStreams.isEmpty()) {

// didn’t find any match. Means there is a broken order somewhere in the streams.

issueReporter.reportError(

Type.GENERIC,

new EvalIssueException(

String.format(

“Unable to add Transform ‘%s’ on variant ‘%s’: requested streams not available: %s+%s / %s”,