override suspend fun run()

in sources/amper-cli/src/org/jetbrains/amper/tasks/android/AndroidAarTask.kt [65:129]
57 lines of code
1 McCabe index (conditional complexity)

    override suspend fun run(dependenciesResult: List<TaskResult>, executionContext: TaskGraphExecutionContext): TaskResult {
        val jarResult = dependenciesResult.filterIsInstance<JvmClassesJarTask.Result>().singleOrNull()
            ?: error("No input classes jar")

        // TODO: Implement picking up actual user-provided assets?
        // TODO: Implement overriding (refining) assets?
        val additionalAssets = dependenciesResult.filterIsInstance<AdditionalAndroidAssetsProvider>()

        val outputAarPath = taskOutputRoot.path / jarResult.jarPath.nameWithoutExtension.plus(".aar")

        val inputFiles = buildList {
            additionalAssets.forEach { result -> result.assetsRoots.forEach { add(it.path) } }
            add(jarResult.jarPath)
        }
        val inputValues = mapOf(
            "outputPath" to outputAarPath.pathString,
            "requiredPackagingDirs" to Json.encodeToString(
                additionalAssets.map { result -> result.assetsRoots.map { it.path.pathString } }
            ),
        )
        incrementalCache.execute(taskName.name, inputValues, inputFiles) {
            outputAarPath.deleteIfExists()
            outputAarPath.createParentDirectories()

            val tempDir = createTempDirectory(tempRoot.path)
            try {
                val manifestStubFile = tempDir / "AndroidManifest.xml"
                // TODO: Use a user-provided Manifest if any? Require it? Require `namespace` to be set for libraries?
                manifestStubFile.writeText(
                    """<?xml version="1.0" encoding="utf-8"?>
                        |<manifest package="${internalPackageNameFor(module)}" />""".trimMargin()
                )
                val assetsDir = Path("assets")
                outputAarPath.writeZip(
                    inputs = buildList {
                        this += ZipInput(
                            path = jarResult.jarPath,
                            destPathInArchive = Path("libs") / jarResult.jarPath.name,
                        )
                        this += ZipInput(
                            path = manifestStubFile,
                            destPathInArchive = manifestStubFile.fileName,
                        )
                        additionalAssets.forEach { asset ->
                            asset.assetsRoots.forEach { assetsRoot ->
                                this += ZipInput(
                                    path = assetsRoot.path,
                                    destPathInArchive = assetsDir / assetsRoot.relativePackagingPath,
                                )
                            }
                        }
                    }
                )
            } finally {
                tempDir.deleteRecursively()
            }
            IncrementalCache.ExecutionResult(
                outputFiles = listOf(outputAarPath),
            )
        }

        return Result(
            aarPath = outputAarPath,
        )
    }