| /* |
| * Copyright 2014-present Facebook, Inc. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); you may |
| * not use this file except in compliance with the License. You may obtain |
| * a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| * License for the specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| package com.facebook.buck.android; |
| |
| import com.facebook.buck.io.ProjectFilesystem; |
| import com.facebook.buck.io.ProjectFilesystem.CopySourceMode; |
| import com.facebook.buck.java.JarDirectoryStepHelper; |
| import com.facebook.buck.java.JavacOptions; |
| import com.facebook.buck.java.PrebuiltJar; |
| import com.facebook.buck.java.PrebuiltJarDescription; |
| import com.facebook.buck.model.BuildTarget; |
| import com.facebook.buck.model.BuildTargets; |
| import com.facebook.buck.model.Flavor; |
| import com.facebook.buck.model.ImmutableFlavor; |
| import com.facebook.buck.model.UnflavoredBuildTarget; |
| import com.facebook.buck.rules.AbstractBuildRule; |
| import com.facebook.buck.rules.BuildContext; |
| import com.facebook.buck.rules.BuildRule; |
| import com.facebook.buck.rules.BuildRuleParams; |
| import com.facebook.buck.rules.BuildRuleResolver; |
| import com.facebook.buck.rules.BuildRuleType; |
| import com.facebook.buck.rules.BuildTargetSourcePath; |
| import com.facebook.buck.rules.BuildableContext; |
| import com.facebook.buck.rules.ImmutableBuildRuleType; |
| import com.facebook.buck.rules.OutputOnlyBuildRule; |
| import com.facebook.buck.rules.RuleKey.Builder; |
| import com.facebook.buck.rules.SourcePath; |
| import com.facebook.buck.rules.SourcePathResolver; |
| import com.facebook.buck.step.AbstractExecutionStep; |
| import com.facebook.buck.step.ExecutionContext; |
| import com.facebook.buck.step.Step; |
| import com.facebook.buck.step.fs.MakeCleanDirectoryStep; |
| import com.facebook.buck.step.fs.MkdirStep; |
| import com.facebook.buck.step.fs.TouchStep; |
| import com.facebook.buck.zip.UnzipStep; |
| import com.google.common.base.Optional; |
| import com.google.common.base.Suppliers; |
| import com.google.common.collect.ImmutableCollection; |
| import com.google.common.collect.ImmutableList; |
| import com.google.common.collect.ImmutableSet; |
| import com.google.common.collect.ImmutableSortedSet; |
| |
| import java.io.IOException; |
| import java.nio.file.Path; |
| import java.util.Collections; |
| import java.util.regex.Pattern; |
| |
| import javax.annotation.Nullable; |
| |
| class AndroidPrebuiltAarGraphEnhancer { |
| |
| private static final BuildRuleType UNZIP_AAR_TYPE = ImmutableBuildRuleType.of("unzip_aar"); |
| |
| private static final Flavor AAR_UNZIP_FLAVOR = ImmutableFlavor.of("aar_unzip"); |
| private static final Flavor AAR_CLASSES_JAR_FLAVOR = ImmutableFlavor.of("aar_classes_jar"); |
| private static final Flavor AAR_MANIFEST = ImmutableFlavor.of("aar_manifest"); |
| private static final Flavor AAR_PREBUILT_JAR_FLAVOR = ImmutableFlavor.of("aar_prebuilt_jar"); |
| private static final Flavor AAR_ANDROID_RESOURCE_FLAVOR = |
| ImmutableFlavor.of("aar_android_resource"); |
| |
| /** Utility class: do not instantiate. */ |
| private AndroidPrebuiltAarGraphEnhancer() {} |
| |
| /** |
| * Creates a rooted DAG of build rules: |
| * <ul> |
| * <li>{@code unzip_aar} depends on the deps specified to the original {@code android_aar} |
| * <li>{@code classes_jar} depends on {@code unzip_aar} |
| * <li>{@code prebuilt_jar} depends on {@code unzip_aar} and {@code classes_jar} |
| * <li>{@code android_resource} depends on {@code unzip_aar} |
| * <li>{@code android_library} depends on {@code android_resource}, {@code prebuilt_jar}, and |
| * {@code unzip_aar} |
| * </ul> |
| * Therefore, the return value is an {link AndroidLibrary} with no {@code srcs}. |
| */ |
| static AndroidPrebuiltAar enhance( |
| BuildRuleParams originalBuildRuleParams, |
| SourcePath aarFile, |
| BuildRuleResolver ruleResolver, |
| JavacOptions javacOptions) { |
| SourcePathResolver pathResolver = new SourcePathResolver(ruleResolver); |
| |
| UnflavoredBuildTarget originalBuildTarget = |
| originalBuildRuleParams.getBuildTarget().checkUnflavored(); |
| |
| // unzip_aar |
| BuildRuleParams unzipAarParams = originalBuildRuleParams.copyWithChanges( |
| UNZIP_AAR_TYPE, |
| BuildTargets.createFlavoredBuildTarget(originalBuildTarget, AAR_UNZIP_FLAVOR), |
| Suppliers.ofInstance(originalBuildRuleParams.getDeclaredDeps()), |
| Suppliers.ofInstance(originalBuildRuleParams.getExtraDeps())); |
| UnzipAar unzipAar = new UnzipAar(unzipAarParams, pathResolver, aarFile); |
| ruleResolver.addToIndex(unzipAar); |
| |
| // unzip_aar#aar_classes_jar |
| BuildRuleParams classesJarParams = originalBuildRuleParams.copyWithChanges( |
| OutputOnlyBuildRule.TYPE, |
| BuildTargets.createFlavoredBuildTarget(originalBuildTarget, AAR_CLASSES_JAR_FLAVOR), |
| /* declaredDeps */ Suppliers.ofInstance(ImmutableSortedSet.<BuildRule>of(unzipAar)), |
| /* extraDeps */ Suppliers.ofInstance(ImmutableSortedSet.<BuildRule>of())); |
| OutputOnlyBuildRule classesJar = new OutputOnlyBuildRule( |
| classesJarParams, |
| pathResolver, |
| unzipAar.getPathToClassesJar()); |
| ruleResolver.addToIndex(classesJar); |
| |
| // prebuilt_jar |
| BuildRuleParams prebuiltJarParams = originalBuildRuleParams.copyWithChanges( |
| PrebuiltJarDescription.TYPE, |
| BuildTargets.createFlavoredBuildTarget(originalBuildTarget, AAR_PREBUILT_JAR_FLAVOR), |
| /* declaredDeps */ |
| Suppliers.ofInstance(ImmutableSortedSet.<BuildRule>of(unzipAar, classesJar)), |
| /* extraDeps */ Suppliers.ofInstance(ImmutableSortedSet.<BuildRule>of())); |
| PrebuiltJar prebuiltJar = new PrebuiltJar( |
| /* params */ prebuiltJarParams, |
| pathResolver, |
| new BuildTargetSourcePath(classesJar.getProjectFilesystem(), classesJar.getBuildTarget()), |
| /* sourceJar */ Optional.<SourcePath>absent(), |
| /* gwtJar */ Optional.<SourcePath>absent(), |
| /* javadocUrl */ Optional.<String>absent()); |
| ruleResolver.addToIndex(prebuiltJar); |
| |
| // unzip_aar#aar_manifest |
| BuildRuleParams manifestParams = originalBuildRuleParams.copyWithChanges( |
| OutputOnlyBuildRule.TYPE, |
| BuildTargets.createFlavoredBuildTarget(originalBuildTarget, AAR_MANIFEST), |
| /* declaredDeps */ Suppliers.ofInstance(ImmutableSortedSet.<BuildRule>of(unzipAar)), |
| /* extraDeps */ Suppliers.ofInstance(ImmutableSortedSet.<BuildRule>of())); |
| OutputOnlyBuildRule manifest = new OutputOnlyBuildRule( |
| manifestParams, |
| pathResolver, |
| unzipAar.getAndroidManifest()); |
| ruleResolver.addToIndex(manifest); |
| |
| // android_resource |
| BuildRuleParams androidResourceParams = originalBuildRuleParams.copyWithChanges( |
| AndroidResourceDescription.TYPE, |
| BuildTargets.createFlavoredBuildTarget(originalBuildTarget, AAR_ANDROID_RESOURCE_FLAVOR), |
| /* declaredDeps */ Suppliers.ofInstance(ImmutableSortedSet.<BuildRule>of(manifest)), |
| /* extraDeps */ Suppliers.ofInstance(ImmutableSortedSet.<BuildRule>of())); |
| |
| // Because all resources and assets are generated files, we specify them as empty collections. |
| ImmutableSortedSet<Path> resSrcs = ImmutableSortedSet.of(); |
| ImmutableSortedSet<Path> assetsSrcs = ImmutableSortedSet.of(); |
| |
| AndroidResource androidResource = new AndroidResource( |
| androidResourceParams, |
| pathResolver, |
| /* deps */ ImmutableSortedSet.<BuildRule>of(unzipAar), |
| unzipAar.getResDirectory(), |
| resSrcs, |
| /* rDotJavaPackage */ null, |
| /* assets */ unzipAar.getAssetsDirectory(), |
| assetsSrcs, |
| new BuildTargetSourcePath(manifest.getProjectFilesystem(), manifest.getBuildTarget()), |
| /* hasWhitelistedStrings */ false); |
| ruleResolver.addToIndex(androidResource); |
| |
| // android_library |
| BuildRuleParams androidLibraryParams = originalBuildRuleParams.copyWithChanges( |
| AndroidLibraryDescription.TYPE, |
| BuildTarget.of(originalBuildTarget), |
| /* declaredDeps */ Suppliers.ofInstance( |
| ImmutableSortedSet.<BuildRule>of( |
| androidResource, |
| prebuiltJar, |
| unzipAar)), |
| /* extraDeps */ Suppliers.ofInstance(ImmutableSortedSet.<BuildRule>of())); |
| return new AndroidPrebuiltAar( |
| androidLibraryParams, |
| pathResolver, |
| unzipAar.getProguardConfig(), |
| unzipAar.getNativeLibsDirectory(), |
| prebuiltJar, |
| androidResource, |
| javacOptions); |
| } |
| |
| private static class UnzipAar extends AbstractBuildRule { |
| |
| private final SourcePath aarFile; |
| private final Path unpackDirectory; |
| private final Path uberClassesJar; |
| |
| private UnzipAar( |
| BuildRuleParams buildRuleParams, |
| SourcePathResolver resolver, |
| SourcePath aarFile) { |
| super(buildRuleParams, resolver); |
| this.aarFile = aarFile; |
| this.unpackDirectory = BuildTargets.getBinPath( |
| buildRuleParams.getBuildTarget(), |
| "__unpack_%s__"); |
| this.uberClassesJar = BuildTargets.getBinPath( |
| buildRuleParams.getBuildTarget(), |
| "__uber_classes_%s__/classes.jar"); |
| } |
| |
| @Override |
| public ImmutableList<Step> getBuildSteps(BuildContext context, |
| BuildableContext buildableContext) { |
| ImmutableList.Builder<Step> steps = ImmutableList.builder(); |
| steps.add(new MakeCleanDirectoryStep(unpackDirectory)); |
| steps.add(new UnzipStep(getResolver().getPath(aarFile), unpackDirectory)); |
| steps.add(new TouchStep(getProguardConfig())); |
| steps.add(new MkdirStep(getAssetsDirectory())); |
| steps.add(new MkdirStep(getNativeLibsDirectory())); |
| |
| // We take the classes.jar file that is required to exist in an .aar and merge it with any |
| // .jar files under libs/ into an "uber" jar. We do this for simplicity because we do not know |
| // how many entries there are in libs/ at graph enhancement time, but we need to make sure |
| // that all of the .class files in the .aar get packaged. As it is implemented today, an |
| // android_library that depends on an android_prebuilt_aar can compile against anything in the |
| // .aar's classes.jar or libs/. |
| steps.add(new MkdirStep(uberClassesJar.getParent())); |
| steps.add(new AbstractExecutionStep("create_uber_classes_jar") { |
| @Override |
| public int execute(ExecutionContext context) { |
| ProjectFilesystem projectFilesystem = context.getProjectFilesystem(); |
| Path libsDirectory = unpackDirectory.resolve("libs"); |
| boolean dirDoesNotExistOrIsEmpty; |
| if (!projectFilesystem.exists(libsDirectory)) { |
| dirDoesNotExistOrIsEmpty = true; |
| } else { |
| try { |
| dirDoesNotExistOrIsEmpty = |
| projectFilesystem.getDirectoryContents(libsDirectory).isEmpty(); |
| } catch (IOException e) { |
| context.logError(e, "Failed to get directory contents of %s", libsDirectory); |
| return 1; |
| } |
| } |
| |
| Path classesJar = unpackDirectory.resolve("classes.jar"); |
| if (dirDoesNotExistOrIsEmpty) { |
| try { |
| projectFilesystem.copy(classesJar, uberClassesJar, CopySourceMode.FILE); |
| } catch (IOException e) { |
| context.logError(e, "Failed to copy from %s to %s", classesJar, uberClassesJar); |
| return 1; |
| } |
| } else { |
| // Glob all of the contents from classes.jar and the entries in libs/ into a single JAR. |
| ImmutableSet.Builder<Path> entriesToJarBuilder = ImmutableSet.builder(); |
| entriesToJarBuilder.add(classesJar); |
| try { |
| entriesToJarBuilder.addAll(projectFilesystem.getDirectoryContents(libsDirectory)); |
| } catch (IOException e) { |
| context.logError(e, "Failed to get directory contents of %s", libsDirectory); |
| return 1; |
| } |
| |
| ImmutableSet<Path> entriesToJar = entriesToJarBuilder.build(); |
| try { |
| JarDirectoryStepHelper.createJarFile( |
| uberClassesJar, |
| entriesToJar, |
| /* mainClass */ null, |
| /* manifestFile */ null, |
| /* mergeManifests */ true, |
| /* blacklist */ ImmutableList.<Pattern>of(), |
| context); |
| } catch (IOException e) { |
| context.logError(e, "Failed to jar %s into %s", entriesToJar, uberClassesJar); |
| return 1; |
| } |
| } |
| return 0; |
| } |
| }); |
| |
| buildableContext.recordArtifactsInDirectory(unpackDirectory); |
| buildableContext.recordArtifact(uberClassesJar); |
| return steps.build(); |
| } |
| |
| @Override |
| @Nullable |
| public Path getPathToOutputFile() { |
| return null; |
| } |
| |
| @Override |
| protected ImmutableCollection<Path> getInputsToCompareToOutput() { |
| return getResolver().filterInputsToCompareToOutput(Collections.singleton(aarFile)); |
| } |
| |
| @Override |
| protected Builder appendDetailsToRuleKey(Builder builder) { |
| return builder; |
| } |
| |
| Path getPathToClassesJar() { |
| return uberClassesJar; |
| } |
| |
| Path getResDirectory() { |
| return unpackDirectory.resolve("res"); |
| } |
| |
| Path getAssetsDirectory() { |
| return unpackDirectory.resolve("assets"); |
| } |
| |
| Path getAndroidManifest() { |
| return unpackDirectory.resolve("AndroidManifest.xml"); |
| } |
| |
| Path getProguardConfig() { |
| return unpackDirectory.resolve("proguard.txt"); |
| } |
| |
| Path getNativeLibsDirectory() { |
| return unpackDirectory.resolve("jni"); |
| } |
| } |
| } |
