/** * Return true if we should regenerate out-of-date JSON files. */ public static boolean shouldRegenerateOutOfDateJsons(@NonNull Project project) { return AndroidGradleOptions.buildModelOnly(project) || AndroidGradleOptions.buildModelOnlyAdvanced(project) || AndroidGradleOptions.invokedFromIde(project) || AndroidGradleOptions.refreshExternalNativeModel(project); }
/** * Obtains the location where APKs should be placed. * * @return the location for APKs */ @NonNull public File getApkLocation() { return MoreObjects.firstNonNull( AndroidGradleOptions.getApkLocation(project), getDefaultApkLocation()); }
public static boolean isBuildOnlyTargetAbiEnabled(@NonNull Project project) { return getBoolean(project, PROPERTY_BUILD_ONLY_TARGET_ABI); }
/** * Returns true if we should use a cached SDK, false if we should force the re-parsing of the * SDK components. */ public static boolean useCachedSdk(Project project) { // only used cached version of the sdk when in instant run mode but not // syncing. return AndroidGradleOptions.getOptionalCompilationSteps(project).contains( OptionalCompilationStep.INSTANT_DEV) && !AndroidGradleOptions.buildModelOnlyAdvanced(project); }
/** * Returns whether we are just trying to build a model for the IDE instead of building. This * means we will attempt to resolve dependencies even if some are broken/unsupported to avoid * failing the import in the IDE. */ private static EvaluationMode computeModelQueryMode(@NonNull Project project) { if (AndroidGradleOptions.buildModelOnlyAdvanced(project)) { return EvaluationMode.IDE; } if (AndroidGradleOptions.buildModelOnly(project)) { return EvaluationMode.IDE_LEGACY; } return EvaluationMode.STANDARD; }
/** * Creates all InstantRun related transforms after compilation. */ @NonNull public AndroidTask<PreColdSwapTask> createPreColdswapTask( @NonNull Project project) { TransformVariantScope transformVariantScope = variantScope.getTransformVariantScope(); InstantRunBuildContext context = variantScope.getInstantRunBuildContext(); context.setApiLevel( AndroidGradleOptions.getTargetFeatureLevel(project), AndroidGradleOptions.getColdswapMode(project), AndroidGradleOptions.getBuildTargetAbi(project)); context.setDensity(AndroidGradleOptions.getBuildTargetDensity(project)); if (transformVariantScope.getGlobalScope().isActive(OptionalCompilationStep.FULL_APK)) { context.setVerifierStatus(InstantRunVerifierStatus.FULL_BUILD_REQUESTED); } else if (transformVariantScope.getGlobalScope().isActive( OptionalCompilationStep.RESTART_ONLY)) { context.setVerifierStatus(InstantRunVerifierStatus.COLD_SWAP_REQUESTED); } AndroidTask<PreColdSwapTask> preColdSwapTask = androidTasks.create( tasks, new PreColdSwapTask.ConfigAction("preColdswap", transformVariantScope, variantScope)); preColdSwapTask.optionalDependsOn(tasks, verifierTask); return preColdSwapTask; }
@NonNull Set<AndroidDependency> libsToExplodeOut) { boolean needPackageScope = true; if (AndroidGradleOptions.buildModelOnly(project)) { Integer modelLevelInt = AndroidGradleOptions.buildModelOnlyVersion(project); int modelLevel = AndroidProject.MODEL_LEVEL_0_ORIGINAL; if (modelLevelInt != null) { needPackageScope = AndroidGradleOptions.buildModelWithFullDependencies(project);
public static boolean getUseSdkDownload(@NonNull Project project) { return getBoolean(project, PROPERTY_USE_SDK_DOWNLOAD, true) && !invokedFromIde(project); }
/** * Returns the level of model-only mode. * * The model-only mode is triggered when the IDE does a sync, and therefore we do * things a bit differently (don't throw exceptions for instance). Things evolved a bit * over versions and the behavior changes. This reflects the mode to use. * * @param project the project * @return an integer or null if we are not in model-only mode. * * @see AndroidProject#MODEL_LEVEL_0_ORIGINAL * @see AndroidProject#MODEL_LEVEL_1_SYNC_ISSUE * @see AndroidProject#MODEL_LEVEL_2_DONT_USE */ @Nullable public static Integer buildModelOnlyVersion(@NonNull Project project) { String revision = getString(project, AndroidProject.PROPERTY_BUILD_MODEL_ONLY_VERSIONED); if (revision != null) { return Integer.parseInt(revision); } if (getBoolean(project, AndroidProject.PROPERTY_BUILD_MODEL_ONLY_ADVANCED)) { return AndroidProject.MODEL_LEVEL_1_SYNC_ISSUE; } if (getBoolean(project, AndroidProject.PROPERTY_BUILD_MODEL_ONLY)) { return AndroidProject.MODEL_LEVEL_0_ORIGINAL; } return null; }
@NonNull public static Optional<FileCache> getBuildCache(@NonNull Project project) { if (isBuildCacheEnabled(project)) { File buildCacheDir = getBuildCacheDir(project); try { return Optional.of(FileCache.getInstanceWithInterProcessLocking(buildCacheDir)); } catch (Exception exception) { throw new RuntimeException( String.format( "Unable to create the build cache at '%1$s'.\n" + "%2$s", buildCacheDir.getAbsolutePath(), BuildCacheUtils.BUILD_CACHE_TROUBLESHOOTING_MESSAGE), exception); } } else { return Optional.empty(); } }
private void resolveDependencies(Project project) { for (BaseVariantData variantData : variantManager.getVariantDataList()) { final String testedProjectPath = config instanceof TestAndroidConfig ? ((TestAndroidConfig) config).getTargetProjectPath() : null; taskManager.getDependencyManager().resolveDependencies( variantData.getVariantDependency(), testedProjectPath); try { ResolveDependenciesTask.extractAarInParallel( project, variantData.getVariantConfiguration(), AndroidGradleOptions.getBuildCache(project)); } catch (Exception e) { throw new RuntimeException(e); } } }
String abiString = Strings.nullToEmpty(AndroidGradleOptions.getBuildTargetAbi(project)); if (!abiString.isEmpty() && outputDataList.size() > 1) { List<String> abiList = Arrays.asList(abiString.split(",")); String densityString = Strings.nullToEmpty(AndroidGradleOptions.getBuildTargetDensity(project)); Density density = Density.getEnum(densityString);
private Object buildAndroidProject(Project project) { Integer modelLevelInt = AndroidGradleOptions.buildModelOnlyVersion(project); if (modelLevelInt != null) { modelLevel = modelLevelInt; modelWithFullDependency = AndroidGradleOptions.buildModelWithFullDependencies(project);
AndroidGradleOptions.getBuildCache(project); File explodedDir; if (PrepareLibraryTask.shouldUseBuildCache( Preconditions.checkState( !AndroidGradleOptions .isImprovedDependencyResolutionEnabled(project), "Improved dependency resolution must be used with " + "build cache.");
@NonNull final TaskFactory tasks, @NonNull final BaseVariantData<? extends BaseVariantOutputData> variantData) { final boolean generateSourcesOnly = AndroidGradleOptions.generateSourcesOnly(project); final LibraryVariantData libVariantData = (LibraryVariantData) variantData; final GradleVariantConfiguration variantConfig = variantData.getVariantConfiguration(); if (AndroidGradleOptions.isImprovedDependencyResolutionEnabled(project) || variantData.getVariantDependency().isAnnotationsPresent()) { AndroidTask<ExtractAnnotations> extractAnnotationsTask =
@Override public void execute(@NonNull CleanBuildCache task) { task.setDescription("Deletes the build cache directory."); task.setGroup(BasePlugin.BUILD_GROUP); task.setVariantName(""); task.setBuildCacheDirectory( AndroidGradleOptions.getBuildCacheDir(globalScope.getProject())); } }
public void createExternalNativeBuildTasks(TaskFactory tasks, @NonNull VariantScope scope) { ExternalNativeJsonGenerator generator = scope.getExternalNativeJsonGenerator(); if (generator == null) { return; } // Set up JSON generation tasks AndroidTask<?> generateTask = androidTasks.create(tasks, ExternalNativeBuildJsonTask.createTaskConfigAction( generator, scope)); generateTask.dependsOn(tasks, scope.getPreBuildTask()); boolean buildOnlyTargetAbi = AndroidGradleOptions.isBuildOnlyTargetAbiEnabled(project); // Set up build tasks AndroidTask<ExternalNativeBuildTask> buildTask = androidTasks.create( tasks, new ExternalNativeBuildTask.ConfigAction( buildOnlyTargetAbi ? AndroidGradleOptions.getBuildTargetAbi(project) : null, generator, scope, androidBuilder)); buildTask.dependsOn(tasks, generateTask); scope.setExternalNativeBuildTask(buildTask); scope.getCompileTask().dependsOn(tasks, buildTask); // Set up clean tasks Task cleanTask = checkNotNull(tasks.named("clean")); cleanTask.dependsOn(androidTasks.create(tasks, new ExternalNativeCleanTask.ConfigAction( generator, scope, androidBuilder)).getName()); }
boolean multiOutput = variantData.getOutputs().size() > 1; boolean abiSpecified = !Strings.isNullOrEmpty(AndroidGradleOptions.getBuildTargetAbi(project));
library.getArtifactFile(), library.getExtractedFolder(), AndroidGradleOptions.getBuildCache(project), library.getCoordinates());
public static boolean useDeprecatedNdk(@NonNull Project project) { return getBoolean(project, USE_DEPRECATED_NDK); }