| /* |
| * Copyright (C) 2020 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.shrinker.graph |
| |
| import com.android.aapt.Resources |
| import com.android.aapt.Resources.Entry |
| import com.android.aapt.Resources.FileReference |
| import com.android.aapt.Resources.FileReference.Type.PROTO_XML |
| import com.android.aapt.Resources.Reference |
| import com.android.aapt.Resources.ResourceTable |
| import com.android.aapt.Resources.XmlAttribute |
| import com.android.aapt.Resources.XmlElement |
| import com.android.aapt.Resources.XmlNode |
| import com.android.build.shrinker.ResourceShrinkerModel |
| import com.android.build.shrinker.entriesSequence |
| import com.android.ide.common.resources.usage.ResourceUsageModel |
| import com.android.ide.common.resources.usage.ResourceUsageModel.Resource |
| import com.android.ide.common.resources.usage.WebTokenizers |
| import com.android.resources.ResourceType |
| import com.android.utils.SdkUtils.IMAGE_EXTENSIONS |
| import com.google.common.base.Ascii |
| import java.io.IOException |
| import java.nio.charset.StandardCharsets |
| import java.nio.file.Files |
| import java.nio.file.Path |
| |
| /** |
| * Builds resources graph starting from each resource in resource table in proto format and follow |
| * all references to other resources inside inlined values and external files from res/ folder. |
| * |
| * <p>Supports external files in the following formats: |
| * <ul> |
| * <li>XML files compiled to proto format; |
| * <li>HTML, CSS, JS files inside res/raw folder; |
| * <li>Unknown files inside res/raw folder (only looks for 'android_res/<type>/<name>' pattern); |
| * </ul> |
| * |
| * <p>As ID resources don't specify parent-child relations between resources but are just |
| * identifiers for a resource or some part of the resource we don't gather them as references to |
| * examined resource. |
| * |
| * @param resourceRoot path to <module>/res/ folder. |
| * @param resourceTable path to resource table in proto format. |
| */ |
| class ProtoResourcesGraphBuilder( |
| private val resourceRoot: ResFolderFileTree, |
| private val resourceTableProducer: (ResourceShrinkerModel) -> ResourceTable |
| ) : ResourcesGraphBuilder { |
| |
| constructor(resourceRootPath: Path, resourceTablePath: Path) : this( |
| object : ResFolderFileTree { |
| override fun getEntryByName(pathInRes: String): ByteArray { |
| val lazyVal : ByteArray by lazy { |
| Files.readAllBytes(resourceRootPath.resolve(pathInRes)) |
| } |
| return lazyVal |
| } |
| }, |
| { model -> model.readResourceTable(resourceTablePath) } |
| ) |
| override fun buildGraph(model: ResourceShrinkerModel) { |
| resourceTableProducer(model).entriesSequence() |
| .map { (id, _, _, entry) -> |
| model.resourceStore.getResource(id)?.let { |
| ReferencesForResourceFinder(resourceRoot, model, entry, it) |
| } |
| } |
| .filterNotNull() |
| .forEach { it.findReferences() } |
| } |
| } |
| interface ResFolderFileTree { |
| fun getEntryByName(pathInRes: String) : ByteArray |
| } |
| |
| private class ReferencesForResourceFinder( |
| private val resourcesRoot: ResFolderFileTree, |
| private val model: ResourceShrinkerModel, |
| private val entry: Entry, |
| private val current: Resource |
| ) { |
| companion object { |
| /** |
| * 'android_res/' is a synthetic directory for resource references in URL format. For |
| * example: file:///android_res/raw/intro_page. |
| */ |
| private const val ANDROID_RES = "android_res/" |
| |
| private const val CONSTRAINT_REFERENCED_IDS = "constraint_referenced_ids" |
| |
| private fun Reference.asItem(): Resources.Item = |
| Resources.Item.newBuilder().setRef(this).build() |
| } |
| |
| private val webTokenizers: WebTokenizers by lazy { |
| WebTokenizers(object : WebTokenizers.WebTokensCallback { |
| override fun referencedHtmlAttribute(tag: String?, attribute: String?, value: String) { |
| if (attribute == "href" || attribute == "src") { |
| referencedUrl(value) |
| } |
| } |
| |
| override fun referencedJsString(jsString: String) { |
| referencedStringFromWebContent(jsString) |
| } |
| |
| override fun referencedCssUrl(url: String) { |
| referencedUrl(url) |
| } |
| |
| private fun referencedUrl(url: String) { |
| // 1. if url contains '/' try to find resources from this web url. |
| // 2. if there is no '/' it might be just relative reference to another resource. |
| val resources = when { |
| url.contains('/') -> model.resourceStore.getResourcesFromWebUrl(url) |
| else -> |
| model.resourceStore.getResources(ResourceType.RAW, url.substringBefore('.')) |
| } |
| if (resources.isNotEmpty()) { |
| resources.forEach { current.addReference(it) } |
| } else { |
| // if there is no resources found by provided url just gather this string as |
| // found inside web content to process it afterwards. |
| referencedStringFromWebContent(url) |
| } |
| } |
| |
| private fun referencedStringFromWebContent(string: String) { |
| if (string.isNotEmpty() && string.length <= 80) { |
| model.addStringConstant(string) |
| model.isFoundWebContent = true |
| } |
| } |
| }) |
| } |
| |
| fun findReferences() { |
| // Walk through all values of the entry and find all Item instances that may reference |
| // other resources in resource table itself or specify external files that should be |
| // analyzed for references. |
| entry.configValueList.asSequence() |
| .map { it.value } |
| .flatMap { value -> |
| val compoundValue = value.compoundValue |
| // compoundValue.attr and compoundValue.styleable are skipped, attr defines |
| // references to ID resources only, but ID and STYLEABLE resources are not supported |
| // by shrinker. |
| when { |
| value.hasItem() -> |
| sequenceOf(value.item) |
| compoundValue.hasStyle() -> |
| sequenceOf(compoundValue.style.parent.asItem()) + |
| compoundValue.style.entryList.asSequence().flatMap { |
| sequenceOf( |
| it.item, |
| it.key.asItem() |
| ) |
| } |
| compoundValue.hasArray() -> |
| compoundValue.array.elementList.asSequence().map { it.item } |
| compoundValue.hasPlural() -> |
| compoundValue.plural.entryList.asSequence().map { it.item } |
| else -> emptySequence() |
| } |
| } |
| .forEach { findFromItem(it) } |
| } |
| |
| private fun findFromItem(item: Resources.Item) { |
| try { |
| when { |
| item.hasRef() -> findFromReference(item.ref) |
| item.hasFile() && item.file.path.startsWith("res/") -> findFromFile(item.file) |
| } |
| } catch (e: IOException) { |
| model.debugReporter.debug { "File '${item.file.path}' can not be processed. Skipping." } |
| } |
| } |
| |
| private fun findFromReference(reference: Reference) { |
| // Reference object may have id of referenced resource, in this case prefer resolved id. |
| // In case id is not provided try to find referenced resource by name. Name is converted |
| // to resource url here, because name in resource table is not normalized to R style field |
| // and to find it we need normalize it first (for example, in case name in resource table is |
| // MyStyle.Child in R file it is R.style.MyStyle_child). |
| val referencedResources = when { |
| reference.id != 0 -> listOf(model.resourceStore.getResource(reference.id)) |
| reference.name.isNotEmpty() -> |
| model.resourceStore.getResourcesFromUrl("@${reference.name}") |
| else -> emptyList() |
| } |
| // IDs are not supported by shrinker for now, just skip it. |
| referencedResources.asSequence() |
| .filterNotNull() |
| .filter { it.type != ResourceType.ID } |
| .forEach { current.addReference(it) } |
| } |
| |
| private fun findFromFile(file: FileReference) { |
| val bytes = resourcesRoot.getEntryByName(file.path.substringAfter("res/")) |
| val content: String by lazy { String(bytes, StandardCharsets.UTF_8) } |
| val extension = Ascii.toLowerCase(file.path.substringAfterLast('.')) |
| when { |
| file.type == PROTO_XML -> fillFromXmlNode(XmlNode.parseFrom(bytes)) |
| extension in listOf("html", "htm") -> webTokenizers.tokenizeHtml(content) |
| extension == "css" -> webTokenizers.tokenizeCss(content) |
| extension == "js" -> webTokenizers.tokenizeJs(content) |
| extension !in IMAGE_EXTENSIONS -> maybeAndroidResUrl(content, markAsReachable = false) |
| } |
| } |
| |
| private fun fillFromXmlNode(node: XmlNode) { |
| // Check for possible reference as 'android_res/<type>/<name>' pattern inside element text. |
| if (current.type == ResourceType.XML) { |
| maybeAndroidResUrl(node.text, markAsReachable = true) |
| } |
| // Check special xml element <rawPathResId> which provides reference to res/raw/ apk |
| // resource for wear application. Applies to all XML files for now but might be re-scoped |
| // to only apply to <wearableApp> XMLs. |
| maybeWearAppReference(node.element) |
| node.element.attributeList.forEach { fillFromAttribute(it) } |
| node.element.childList.forEach { fillFromXmlNode(it) } |
| } |
| |
| private fun fillFromAttribute(attribute: XmlAttribute) { |
| if (attribute.name == CONSTRAINT_REFERENCED_IDS) { |
| fillFromConstraintReferencedIds(attribute.value) |
| } |
| if (attribute.hasCompiledItem()) { |
| findFromItem(attribute.compiledItem) |
| } |
| // Check for possible reference as 'android_res/<type>/<name>' pattern inside attribute val. |
| if (current.type == ResourceType.XML) { |
| maybeAndroidResUrl(attribute.value, markAsReachable = true) |
| } |
| } |
| |
| private fun fillFromConstraintReferencedIds(value: String?) { |
| value |
| ?.split(",") |
| ?.map { it.trim() } |
| ?.forEach { |
| model.resourceStore.getResources(ResourceType.ID, it) |
| .forEach(ResourceUsageModel::markReachable) |
| } |
| } |
| |
| private fun maybeAndroidResUrl(text: String, markAsReachable: Boolean) { |
| findAndroidResReferencesInText(text) |
| .map { it.split('/', limit = 2) } |
| .filter { it.size == 2 } |
| .map { (dir, fileName) -> |
| Pair( |
| ResourceType.fromFolderName(dir.substringBefore('-')), |
| fileName.substringBefore('.') |
| ) |
| } |
| .filter { (type, _) -> type != null } |
| .flatMap { (type, name) -> model.resourceStore.getResources(type!!, name).asSequence() } |
| .forEach { |
| if (markAsReachable) { |
| ResourceUsageModel.markReachable(it) |
| } else { |
| current.addReference(it) |
| } |
| } |
| } |
| |
| private fun maybeWearAppReference(element: XmlElement) { |
| if (element.name == "rawPathResId") { |
| val rawResourceName = element.childList |
| .map { it.text } |
| .joinToString(separator = "") |
| .trim() |
| |
| model.resourceStore.getResources(ResourceType.RAW, rawResourceName) |
| .forEach { current.addReference(it) } |
| } |
| } |
| |
| /** |
| * Splits input text to parts that starts with 'android_res/' and returns sequence of strings |
| * between 'android_res/' occurrences and first whitespace after it. This method is used instead |
| * of {@link CharSequence#splitToSequence} because does not spawn full substrings between |
| * 'android_res/' in memory when text is big enough. |
| */ |
| private fun findAndroidResReferencesInText(text: String): Sequence<String> = sequence { |
| var start = 0 |
| while (start < text.length) { |
| start = text.indexOf(ANDROID_RES, start) |
| if (start == -1) { |
| break |
| } |
| var end = start + ANDROID_RES.length |
| while (end < text.length && !Character.isWhitespace(text[end])) { |
| end++ |
| } |
| yield(text.substring(start + ANDROID_RES.length, end)) |
| start = end |
| } |
| } |
| } |
