| /* |
| * Copyright (C) 2012 The Android Open Source Project |
| * |
| * 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.android.build.gradle.tasks |
| |
| import com.android.build.api.component.impl.ComponentPropertiesImpl |
| import com.android.build.gradle.internal.LoggerWrapper |
| import com.android.build.gradle.internal.SdkComponentsBuildService |
| import com.android.build.gradle.internal.process.GradleProcessExecutor |
| import com.android.build.gradle.internal.publishing.AndroidArtifacts.ArtifactScope.ALL |
| import com.android.build.gradle.internal.publishing.AndroidArtifacts.ArtifactType.RENDERSCRIPT |
| import com.android.build.gradle.internal.publishing.AndroidArtifacts.ConsumedConfigType.COMPILE_CLASSPATH |
| import com.android.build.gradle.internal.scope.InternalArtifactType.RENDERSCRIPT_LIB |
| import com.android.build.gradle.internal.scope.InternalArtifactType.RENDERSCRIPT_SOURCE_OUTPUT_DIR |
| import com.android.build.gradle.internal.services.getBuildService |
| import com.android.build.gradle.internal.tasks.NdkTask |
| import com.android.build.gradle.internal.tasks.factory.VariantTaskCreationAction |
| import com.android.build.gradle.internal.utils.setDisallowChanges |
| import com.android.build.gradle.options.BooleanOption |
| import com.android.builder.internal.compiler.DirectoryWalker |
| import com.android.builder.internal.compiler.RenderScriptProcessor |
| import com.android.ide.common.process.LoggedProcessOutputHandler |
| import com.android.ide.common.process.ProcessOutputHandler |
| import com.android.repository.Revision |
| import com.android.sdklib.BuildToolInfo |
| import com.android.utils.FileUtils |
| import com.google.common.base.Preconditions.checkNotNull |
| import com.google.common.collect.Lists |
| import com.google.common.collect.Sets |
| import org.gradle.api.file.DirectoryProperty |
| import org.gradle.api.file.FileCollection |
| import org.gradle.api.provider.Property |
| import org.gradle.api.tasks.CacheableTask |
| import org.gradle.api.tasks.Input |
| import org.gradle.api.tasks.InputFiles |
| import org.gradle.api.tasks.Internal |
| import org.gradle.api.tasks.OutputDirectory |
| import org.gradle.api.tasks.PathSensitive |
| import org.gradle.api.tasks.PathSensitivity |
| import org.gradle.api.tasks.SkipWhenEmpty |
| import org.gradle.api.tasks.TaskProvider |
| import org.gradle.process.ExecOperations |
| import java.io.File |
| import java.io.IOException |
| import java.util.concurrent.Callable |
| import javax.inject.Inject |
| |
| /** Task to compile Renderscript files. Supports incremental update. */ |
| @CacheableTask |
| abstract class RenderscriptCompile : NdkTask() { |
| |
| // ----- PUBLIC TASK API ----- |
| |
| @get:OutputDirectory |
| lateinit var resOutputDir: File |
| |
| @get:OutputDirectory |
| lateinit var objOutputDir: File |
| |
| // ----- PRIVATE TASK API ----- |
| |
| @get:InputFiles |
| @get:PathSensitive(PathSensitivity.RELATIVE) |
| lateinit var importDirs: FileCollection |
| |
| @get:Input |
| abstract val targetApi: Property<Int> |
| |
| @get:Input |
| var isSupportMode: Boolean = false |
| |
| @get:Input |
| var useAndroidX: Boolean = false |
| private set |
| |
| @get:Input |
| var optimLevel: Int = 0 |
| |
| @get:Input |
| var isNdkMode: Boolean = false |
| |
| @Input |
| fun getBuildToolsVersion(): String = |
| sdkBuildService.get().buildToolInfoProvider.get().revision.toString() |
| |
| @get:Internal |
| abstract val sdkBuildService: Property<SdkComponentsBuildService> |
| |
| @get:OutputDirectory |
| abstract val sourceOutputDir: DirectoryProperty |
| |
| @get:OutputDirectory |
| abstract val libOutputDir: DirectoryProperty |
| |
| @get:Inject |
| abstract val execOperations: ExecOperations |
| |
| // get the import folders. If the .rsh files are not directly under the import folders, |
| // we need to get the leaf folders, as this is what llvm-rs-cc expects. |
| // TODO: should "rsh" be a constant somewhere? |
| private val importFolders: Collection<File> |
| get() { |
| val results = Sets.newHashSet<File>() |
| |
| val dirs = Lists.newArrayList<File>() |
| dirs.addAll(importDirs.files) |
| dirs.addAll(sourceDirs.files) |
| |
| for (dir in dirs) { |
| DirectoryWalker.builder() |
| .root(dir.toPath()) |
| .extensions("rsh") |
| .action { _, path -> results.add(path.parent.toFile()) } |
| .build() |
| .walk() |
| } |
| |
| return results |
| } |
| |
| private lateinit var sourceDirs: FileCollection |
| |
| @InputFiles |
| @PathSensitive(PathSensitivity.RELATIVE) |
| @SkipWhenEmpty |
| fun getSourceDirs(): FileCollection { |
| return sourceDirs.asFileTree |
| } |
| |
| override fun doTaskAction() { |
| // this is full run (always), clean the previous outputs |
| val sourceDestDir = sourceOutputDir.get().asFile |
| FileUtils.cleanOutputDir(sourceDestDir) |
| |
| val resDestDir = resOutputDir |
| FileUtils.cleanOutputDir(resDestDir) |
| |
| val objDestDir = objOutputDir |
| FileUtils.cleanOutputDir(objDestDir) |
| |
| val libDestDir = libOutputDir.get().asFile |
| FileUtils.cleanOutputDir(libDestDir) |
| |
| val sourceDirectories = sourceDirs.files |
| |
| val buildToolsInfo = sdkBuildService.get().buildToolInfoProvider.get() |
| compileAllRenderscriptFiles( |
| sourceDirectories, |
| importFolders, |
| sourceDestDir, |
| resDestDir, |
| objDestDir, |
| libDestDir, |
| targetApi.get(), |
| buildToolsInfo.revision, |
| optimLevel, |
| isNdkMode, |
| isSupportMode, |
| useAndroidX, |
| ndkConfig?.abiFilters ?: setOf(), |
| LoggedProcessOutputHandler(LoggerWrapper(logger)), |
| buildToolsInfo |
| ) |
| } |
| |
| /** |
| * Compiles all the renderscript files found in the given source folders. |
| * |
| * |
| * Right now this is the only way to compile them as the renderscript compiler requires all |
| * renderscript files to be passed for all compilation. |
| * |
| * |
| * Therefore whenever a renderscript file or header changes, all must be recompiled. |
| * |
| * @param sourceFolders all the source folders to find files to compile |
| * @param importFolders all the import folders. |
| * @param sourceOutputDir the output dir in which to generate the source code |
| * @param resOutputDir the output dir in which to generate the bitcode file |
| * @param targetApi the target api |
| * @param buildToolsRevision the build tools version used |
| * @param optimLevel the optimization level |
| * @param ndkMode whether the renderscript code should be compiled to generate C/C++ bindings |
| * @param supportMode support mode flag to generate .so files. |
| * @param useAndroidX whether to use AndroidX dependencies |
| * @param abiFilters ABI filters in case of support mode |
| * @throws IOException failed |
| * @throws InterruptedException failed |
| */ |
| private fun compileAllRenderscriptFiles( |
| sourceFolders: Collection<File>, |
| importFolders: Collection<File>, |
| sourceOutputDir: File, |
| resOutputDir: File, |
| objOutputDir: File, |
| libOutputDir: File, |
| targetApi: Int, |
| buildToolsRevision: Revision, |
| optimLevel: Int, |
| ndkMode: Boolean, |
| supportMode: Boolean, |
| useAndroidX: Boolean, |
| abiFilters: Set<String>, |
| processOutputHandler: ProcessOutputHandler, |
| buildToolInfo: BuildToolInfo |
| ) { |
| checkNotNull(sourceFolders, "sourceFolders cannot be null.") |
| checkNotNull(importFolders, "importFolders cannot be null.") |
| checkNotNull(sourceOutputDir, "sourceOutputDir cannot be null.") |
| checkNotNull(resOutputDir, "resOutputDir cannot be null.") |
| |
| val renderscript = buildToolInfo.getPath(BuildToolInfo.PathId.LLVM_RS_CC) |
| if (renderscript == null || !File(renderscript).isFile) { |
| throw IllegalStateException("llvm-rs-cc is missing") |
| } |
| |
| val processor = RenderScriptProcessor( |
| sourceFolders, |
| importFolders, |
| sourceOutputDir, |
| resOutputDir, |
| objOutputDir, |
| libOutputDir, |
| buildToolInfo, |
| targetApi, |
| buildToolsRevision, |
| optimLevel, |
| ndkMode, |
| supportMode, |
| useAndroidX, |
| abiFilters, |
| LoggerWrapper(logger) |
| ) |
| processor.build(GradleProcessExecutor(execOperations::exec), processOutputHandler) |
| } |
| |
| // ----- CreationAction ----- |
| |
| class CreationAction( |
| componentProperties: ComponentPropertiesImpl |
| ) : VariantTaskCreationAction<RenderscriptCompile, ComponentPropertiesImpl>( |
| componentProperties |
| ) { |
| |
| override val name: String |
| get() = computeTaskName("compile", "Renderscript") |
| |
| override val type: Class<RenderscriptCompile> |
| get() = RenderscriptCompile::class.java |
| |
| override fun handleProvider( |
| taskProvider: TaskProvider<RenderscriptCompile> |
| ) { |
| super.handleProvider(taskProvider) |
| creationConfig.taskContainer.renderscriptCompileTask = taskProvider |
| creationConfig.artifacts.setInitialProvider( |
| taskProvider, |
| RenderscriptCompile::sourceOutputDir |
| ).withName("out").on(RENDERSCRIPT_SOURCE_OUTPUT_DIR) |
| |
| creationConfig.artifacts.setInitialProvider( |
| taskProvider, |
| RenderscriptCompile::libOutputDir |
| ).withName("lib").on(RENDERSCRIPT_LIB) |
| } |
| |
| override fun configure( |
| task: RenderscriptCompile |
| ) { |
| super.configure(task) |
| |
| val globalScope = creationConfig.globalScope |
| |
| val variantDslInfo = creationConfig.variantDslInfo |
| val variantSources = creationConfig.variantSources |
| |
| val ndkMode = variantDslInfo.renderscriptNdkModeEnabled |
| |
| task.targetApi.set(globalScope.project.provider { |
| variantDslInfo.renderscriptTarget |
| }) |
| task.targetApi.disallowChanges() |
| |
| task.isSupportMode = variantDslInfo.renderscriptSupportModeEnabled |
| task.useAndroidX = creationConfig.services.projectOptions.get(BooleanOption.USE_ANDROID_X) |
| task.isNdkMode = ndkMode |
| task.optimLevel = variantDslInfo.renderscriptOptimLevel |
| |
| task.sourceDirs = globalScope |
| .project |
| .files(Callable { variantSources.renderscriptSourceList }) |
| task.importDirs = creationConfig.variantDependencies.getArtifactFileCollection( |
| COMPILE_CLASSPATH, ALL, RENDERSCRIPT |
| ) |
| |
| task.resOutputDir = creationConfig.paths.renderscriptResOutputDir |
| task.objOutputDir = creationConfig.paths.renderscriptObjOutputDir |
| |
| task.ndkConfig = variantDslInfo.ndkConfig |
| |
| task.sdkBuildService.setDisallowChanges( |
| getBuildService(creationConfig.services.buildServiceRegistry) |
| ) |
| if (creationConfig.variantType.isTestComponent) { |
| task.dependsOn(creationConfig.taskContainer.processManifestTask!!) |
| } |
| } |
| } |
| } |
