| /* |
| * Copyright 2018 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. |
| */ |
| |
| import okhttp3.MediaType |
| import okhttp3.OkHttpClient |
| import okhttp3.Request |
| import okhttp3.RequestBody |
| import org.w3c.dom.Element |
| import org.w3c.dom.Node |
| import java.security.MessageDigest |
| import javax.xml.parsers.DocumentBuilderFactory |
| import javax.xml.transform.OutputKeys |
| import javax.xml.transform.TransformerFactory |
| import javax.xml.transform.dom.DOMSource |
| import javax.xml.transform.stream.StreamResult |
| |
| buildscript { |
| repositories { |
| jcenter() |
| mavenCentral() |
| google() |
| } |
| |
| dependencies { |
| classpath("org.apache.maven:maven-model:3.5.4") |
| classpath("org.apache.maven:maven-model-builder:3.5.4") |
| classpath("com.squareup.okhttp3:okhttp:3.14.7") |
| classpath("javax.inject:javax.inject:1") |
| } |
| } |
| |
| // The output folder inside prebuilts |
| val prebuiltsLocation = file("../../../../prebuilts/androidx") |
| val internalFolder = "internal" |
| val externalFolder = "external" |
| // Passed in as a project property |
| val artifactName = project.findProperty("artifactName") |
| val mediaType = MediaType.get("application/json; charset=utf-8") |
| val licenseEndpoint = "https://fetch-licenses.appspot.com/convert/licenses" |
| |
| val internalArtifacts = listOf( |
| "android.arch(.*)?".toRegex(), |
| "com.android.support(.*)?".toRegex() |
| ) |
| |
| val potentialInternalArtifacts = listOf( |
| "androidx(.*)?".toRegex() |
| ) |
| |
| // Need to exclude androidx.databinding |
| val forceExternal = setOf( |
| ".databinding" |
| ) |
| |
| plugins { |
| java |
| } |
| |
| repositories { |
| jcenter() |
| mavenCentral() |
| google() |
| gradlePluginPortal() |
| val metalavaBuildId: String? = findProperty("metalavaBuildId") as String? |
| if (metalavaBuildId != null) { |
| maven(url="https://androidx.dev/metalava/builds/${metalavaBuildId}/artifacts/repo/m2repository") |
| } |
| |
| ivy { |
| setUrl("https://download.jetbrains.com/kotlin/native/builds/releases") |
| patternLayout { |
| artifact("[revision]/macos/[artifact]-[revision].[ext]") |
| } |
| metadataSources { |
| artifact() |
| } |
| content { |
| includeGroup("") |
| } |
| } |
| ivy { |
| setUrl("https://download.jetbrains.com/kotlin/native/builds/releases") |
| patternLayout { |
| artifact("[revision]/linux/[artifact]-[revision].[ext]") |
| } |
| metadataSources { |
| artifact() |
| } |
| content { |
| includeGroup("") |
| } |
| } |
| } |
| |
| val allFilesWithDependencies: Configuration by configurations.creating { |
| attributes { |
| // We define this attribute in DirectMetadataAccessVariantRule |
| attribute(DocsType.DOCS_TYPE_ATTRIBUTE, objects.named("all-files-with-dependencies")) |
| } |
| extendsFrom(configurations.runtimeClasspath.get()) |
| } |
| |
| if (artifactName != null) { |
| dependencies { |
| // This is the configuration container that we use to lookup the |
| // transitive closure of all dependencies. |
| implementation(artifactName) |
| |
| // For metadata access |
| components { |
| all<DirectMetadataAccessVariantRule>() |
| } |
| } |
| } |
| |
| /** |
| * Checks if an artifact is *internal*. |
| */ |
| fun isInternalArtifact(artifact: ResolvedArtifactResult): Boolean { |
| val component = artifact.id.componentIdentifier as? ModuleComponentIdentifier |
| if (component != null) { |
| val group = component.group |
| for (regex in internalArtifacts) { |
| val match = regex.matches(group) |
| if (match) { |
| return true |
| } |
| } |
| |
| for (regex in potentialInternalArtifacts) { |
| val matchResult = regex.matchEntire(group) |
| val match = regex.matches(group) && |
| matchResult?.destructured?.let { (sub) -> |
| !forceExternal.contains(sub) |
| } ?: true |
| if (match) { |
| return true |
| } |
| } |
| } |
| return false |
| } |
| |
| /** |
| * Helps generate digests for the artifacts. |
| */ |
| fun digest(file: File, algorithm: String): File { |
| val messageDigest = MessageDigest.getInstance(algorithm) |
| val contents = file.readBytes() |
| val digestBytes = messageDigest.digest(contents) |
| val builder = StringBuilder() |
| for (byte in digestBytes) { |
| builder.append(String.format("%02x", byte)) |
| } |
| val parent = System.getProperty("java.io.tmpdir") |
| val outputFile = File(parent, "${file.name}.${algorithm.toLowerCase()}") |
| outputFile.deleteOnExit() |
| outputFile.writeText(builder.toString()) |
| return outputFile |
| } |
| |
| /** |
| * Fetches license information for external dependencies. |
| */ |
| fun licenseFor(pomFile: File): File? { |
| try { |
| val builder = DocumentBuilderFactory.newInstance().newDocumentBuilder() |
| val document = builder.parse(pomFile) |
| val client = OkHttpClient() |
| /* |
| This is what a licenses declaration looks like: |
| <licenses> |
| <license> |
| <name>Android Software Development Kit License</name> |
| <url>https://developer.android.com/studio/terms.html</url> |
| <distribution>repo</distribution> |
| </license> |
| </licenses> |
| */ |
| val licenses = document.getElementsByTagName("license") |
| for (i in 0 until licenses.length) { |
| val license = licenses.item(i) |
| val children = license.childNodes |
| for (j in 0 until children.length) { |
| val element = children.item(j) |
| if (element.nodeName.toLowerCase() == "url") { |
| val url = element.textContent |
| val payload = RequestBody.create(mediaType, "{\"url\": \"$url\"}") |
| val request = Request.Builder().url(licenseEndpoint).post(payload).build() |
| val response = client.newCall(request).execute() |
| val contents = response.body()?.string() |
| if (contents != null) { |
| val parent = System.getProperty("java.io.tmpdir") |
| val outputFile = File(parent, "${pomFile.name}.LICENSE") |
| outputFile.deleteOnExit() |
| outputFile.writeText(contents) |
| return outputFile |
| } |
| } |
| } |
| } |
| } catch (exception: Throwable) { |
| println("Error fetching license information for $pomFile") |
| } |
| return null |
| } |
| |
| /** |
| * Transforms POM files so we automatically comment out nodes with <type>aar</type>. |
| * |
| * We are doing this for all internal libraries to account for -PuseMaxDepVersions which swaps out |
| * the dependencies of all androidx libraries with their respective ToT versions. |
| * For more information look at b/127495641. |
| */ |
| fun transformInternalPomFile(file: File): File { |
| val factory = DocumentBuilderFactory.newInstance() |
| val builder = factory.newDocumentBuilder() |
| val document = builder.parse(file) |
| document.normalizeDocument() |
| |
| val container = document.getElementsByTagName("dependencies") |
| if (container.length <= 0) { |
| return file |
| } |
| |
| fun findTypeAar(dependency: Node): Element? { |
| val children = dependency.childNodes |
| for (i in 0 until children.length) { |
| val node = children.item(i) |
| if (node.nodeType == Node.ELEMENT_NODE) { |
| val element = node as Element |
| if (element.tagName.toLowerCase() == "type" && |
| element.textContent?.toLowerCase() == "aar" |
| ) { |
| return element |
| } |
| } |
| } |
| return null |
| } |
| |
| for (i in 0 until container.length) { |
| val dependencies = container.item(i) |
| for (j in 0 until dependencies.childNodes.length) { |
| val dependency = dependencies.childNodes.item(j) |
| val element = findTypeAar(dependency) |
| if (element != null) { |
| val replacement = document.createComment("<type>aar</type>") |
| dependency.replaceChild(replacement, element) |
| } |
| } |
| } |
| |
| val parent = System.getProperty("java.io.tmpdir") |
| val outputFile = File(parent, "${file.name}.transformed") |
| outputFile.deleteOnExit() |
| |
| val transformer = TransformerFactory.newInstance().newTransformer() |
| val domSource = DOMSource(document) |
| val result = StreamResult(outputFile) |
| transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "true") |
| transformer.setOutputProperty(OutputKeys.INDENT, "true") |
| transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8") |
| transformer.transform(domSource, result) |
| return outputFile |
| } |
| |
| /** |
| * Copies artifacts to the right locations. |
| */ |
| fun copyArtifact(artifact: ResolvedArtifactResult, internal: Boolean = false) { |
| val folder = if (internal) internalFolder else externalFolder |
| val file = artifact.file |
| val component = artifact.id.componentIdentifier as? ModuleComponentIdentifier |
| if (component != null) { |
| val group = component.group |
| val moduleName = component.module |
| val moduleVersion = component.version |
| val groupPath = groupToPath(group) |
| val pathComponents = listOf( |
| prebuiltsLocation, |
| folder, |
| groupPath, |
| moduleName, |
| moduleVersion |
| ) |
| val location = pathComponents.joinToString("/") |
| if (file.name.endsWith(".pom")) { |
| copyPomFile(group, moduleName, moduleVersion, file, internal) |
| } else { |
| println("Copying ${file.name} to $location") |
| copy { |
| from( |
| file, |
| digest(file, "MD5"), |
| digest(file, "SHA1") |
| ) |
| into(location) |
| } |
| } |
| } |
| } |
| |
| /** |
| * Copies associated POM files to the right location. |
| */ |
| fun copyPomFile( |
| group: String, |
| name: String, |
| version: String, |
| pomFile: File, |
| internal: Boolean = false |
| ) { |
| val folder = if (internal) internalFolder else externalFolder |
| val groupPath = groupToPath(group) |
| val pathComponents = listOf( |
| prebuiltsLocation, |
| folder, |
| groupPath, |
| name, |
| version |
| ) |
| val location = pathComponents.joinToString("/") |
| // Copy associated POM files. |
| val transformed = if (internal) transformInternalPomFile(pomFile) else pomFile |
| println("Copying ${pomFile.name} to $location") |
| copy { |
| from(transformed) |
| into(location) |
| rename { |
| pomFile.name |
| } |
| } |
| // Keep original MD5 and SHA1 hashes |
| copy { |
| from( |
| digest(pomFile, "MD5"), |
| digest(pomFile, "SHA1") |
| ) |
| into(location) |
| } |
| // Copy licenses if available for external dependencies |
| val license = if (!internal) licenseFor(pomFile) else null |
| if (license != null) { |
| println("Copying License files for ${pomFile.name} to $location") |
| copy { |
| from(license) |
| into(location) |
| // rename to a file called LICENSE |
| rename { "LICENSE" } |
| } |
| } |
| } |
| |
| /** |
| * Given a groupId, returns a relative filepath telling where to place that group |
| */ |
| fun groupToPath(group: String): String { |
| if (group != "") { |
| return group.split(".").joinToString("/") |
| } else { |
| return "no-group" |
| } |
| } |
| |
| /** |
| * This rule runs in a sandbox, and does not have access ot things in scope which it should usually |
| * have access to. This is why the constant `all-files-with-dependencies` is being duplicated. |
| */ |
| @CacheableRule |
| open class DirectMetadataAccessVariantRule : ComponentMetadataRule { |
| |
| @javax.inject.Inject |
| open fun getObjects(): ObjectFactory = throw UnsupportedOperationException() |
| |
| override fun execute(ctx: ComponentMetadataContext) { |
| val id = ctx.details.id |
| ctx.details.maybeAddVariant("allFilesWithDependenciesElements", "runtimeElements") { |
| attributes { |
| attribute(Usage.USAGE_ATTRIBUTE, getObjects().named(Usage.JAVA_RUNTIME)) |
| attribute(Category.CATEGORY_ATTRIBUTE, getObjects().named(Category.DOCUMENTATION)) |
| attribute( |
| DocsType.DOCS_TYPE_ATTRIBUTE, |
| getObjects().named("all-files-with-dependencies") |
| ) |
| } |
| withFiles { |
| addFile("${id.name}-${id.version}.pom") |
| addFile("${id.name}-${id.version}.module") |
| addFile("${id.name}-${id.version}.jar") |
| addFile("${id.name}-${id.version}.aar") |
| addFile("${id.name}-${id.version}-sources.jar") |
| } |
| } |
| ctx.details.maybeAddVariant("allFilesWithDependencies", "runtime") { |
| attributes { |
| attribute(Usage.USAGE_ATTRIBUTE, getObjects().named(Usage.JAVA_RUNTIME)) |
| attribute(Category.CATEGORY_ATTRIBUTE, getObjects().named(Category.DOCUMENTATION)) |
| attribute( |
| DocsType.DOCS_TYPE_ATTRIBUTE, |
| getObjects().named("all-files-with-dependencies") |
| ) |
| } |
| withFiles { |
| addFile("${id.name}-${id.version}.pom") |
| // No harm in leaving it in here. |
| addFile("${id.name}-${id.version}.module") |
| addFile("${id.name}-${id.version}.jar") |
| addFile("${id.name}-${id.version}.aar") |
| addFile("${id.name}-${id.version}-sources.jar") |
| } |
| } |
| } |
| } |
| |
| tasks { |
| val fetchArtifacts by creating { |
| doLast { |
| println("\r\nAll Files with Dependencies") |
| allFilesWithDependencies.incoming.artifactView { |
| lenient(true) |
| }.artifacts.forEach { |
| copyArtifact(it, internal = isInternalArtifact(it)) |
| } |
| |
| println("\r\nResolved artifacts for $artifactName.") |
| } |
| } |
| } |
| |
| defaultTasks("fetchArtifacts") |
