android-10.0.0_r47/s

/*
 * Copyright (C) 2007 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.
 */

// Copied from tools/base/laoyutlib-api

package com.android.resources;

import com.android.SdkConstants;
import com.google.common.base.Strings;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Sets;
import org.w3c.dom.Element;
import org.w3c.dom.Node;

import java.util.Arrays;
import java.util.function.BiFunction;
import java.util.function.Function;

import static com.google.common.base.MoreObjects.firstNonNull;

/**
 * Enum representing a type of compiled resource.
 *
 * <p>See {@code ResourceType} in aapt2/Resource.h.
 */
public enum ResourceType {
    ANIM("anim", "Animation"),
    ANIMATOR("animator", "Animator"),
    ARRAY("array", "Array", "string-array", "integer-array"),
    ATTR("attr", "Attr"),
    BOOL("bool", "Boolean"),
    COLOR("color", "Color"),
    DIMEN("dimen", "Dimension"),
    DRAWABLE("drawable", "Drawable"),
    FONT("font", "Font"),
    FRACTION("fraction", "Fraction"),
    ID("id", "ID"),
    INTEGER("integer", "Integer"),
    INTERPOLATOR("interpolator", "Interpolator"),
    LAYOUT("layout", "Layout"),
    MENU("menu", "Menu"),
    MIPMAP("mipmap", "Mip Map"),
    NAVIGATION("navigation", "Navigation"),
    PLURALS("plurals", "Plurals"),
    RAW("raw", "Raw"),
    STRING("string", "String"),
    STYLE("style", "Style"),
    STYLEABLE("styleable", "Styleable", Kind.STYLEABLE),
    TRANSITION("transition", "Transition"),
    XML("xml", "XML"),

    /**
     * This is not actually used. Only there because they get parsed and since we want to detect new
     * resource type, we need to have this one exist.
     */
    PUBLIC("public", "Public visibility modifier", Kind.SYNTHETIC),

    /**
     * This type is used for elements dynamically generated by the parsing of aapt:attr nodes. The
     * "aapt:attr" allow to inline resources as part of a different resource, for example, a
     * drawable as part of a layout. When the parser, encounters one of this nodes, it will generate
     * a synthetic _aaptattr reference.
     */
    AAPT("_aapt", "Aapt Attribute", Kind.SYNTHETIC),

    /**
     * Represents item tags inside a style definition.
     */
    STYLE_ITEM("item", "Style Item", Kind.SYNTHETIC),

    /**
     * Not an actual resource type from AAPT. Used to provide sample data values in the tools
     * namespace
     */
    SAMPLE_DATA("sample", "Sample data", Kind.SYNTHETIC),
    ;

    private enum Kind {
        /**
         * These types are used both in the R and as XML tag names.
         */
        REAL,

        /**
         * Styleables are handled by aapt but don't end up in the resource table. They have an R
         * inner class (called {@code styleable}), are declared in XML (using {@code
         * declare-styleable}) but cannot be referenced from XML.
         */
        STYLEABLE,

        /**
         * Other types that are not known to aapt, but are used by tools to represent some
         * information in the resources system.
         */
        SYNTHETIC,
        ;
    }

    private final String mName;
    private final Kind mKind;
    private final String mDisplayName;
    private final String[] mAlternateXmlNames;

    ResourceType(
        String name,
        String displayName,
        String... alternateXmlNames) {
        mName = name;
        mKind = Kind.REAL;
        mDisplayName = displayName;
        mAlternateXmlNames = alternateXmlNames;
    }

    ResourceType(String name, String displayName, Kind kind) {
        mName = name;
        mKind = kind;
        mDisplayName = displayName;
        mAlternateXmlNames = new String[0];
    }

    /**
     * The set of all types of resources that can be referenced by other resources.
     */
    public static final ImmutableSet<ResourceType> REFERENCEABLE_TYPES;

    private static final ImmutableMap<String, ResourceType> TAG_NAMES;
    private static final ImmutableMap<String, ResourceType> CLASS_NAMES;

    static {
        ImmutableMap.Builder<String, ResourceType> tagNames = ImmutableMap.builder();
        tagNames.put(SdkConstants.TAG_DECLARE_STYLEABLE, STYLEABLE);
        tagNames.put(SdkConstants.TAG_PUBLIC, PUBLIC);

        ImmutableMap.Builder<String, ResourceType> classNames = ImmutableMap.builder();
        classNames.put(STYLEABLE.mName, STYLEABLE);
        classNames.put(AAPT.mName, AAPT);

        for (ResourceType type : ResourceType.values()) {
            if (type.mKind != Kind.REAL || type == STYLEABLE) {
                continue;
            }
            classNames.put(type.getName(), type);
            tagNames.put(type.getName(), type);
            for (String alternateName : type.mAlternateXmlNames) {
                tagNames.put(alternateName, type);
            }
        }

        TAG_NAMES = tagNames.build();
        CLASS_NAMES = classNames.build();
        REFERENCEABLE_TYPES =
            Arrays.stream(values())
                .filter(ResourceType::getCanBeReferenced)
                .collect(Sets.toImmutableEnumSet());
    }

    /**
     * Returns the resource type name, as used by XML files.
     */
    public String getName() {
        return mName;
    }

    /**
     * Returns a translated display name for the resource type.
     */
    public String getDisplayName() {
        return mDisplayName;
    }

    /**
     * Returns the enum by its name as it appears in the R class.
     *
     * @param className name of the inner class of the R class, e.g. "string" or "styleable".
     */

    public static ResourceType fromClassName(String className) {
        return CLASS_NAMES.get(className);
    }

    /**
     * Returns the enum by its name as it appears as a folder name under {@code res/}.
     *
     * @param folderName name of the inner class of the R class, e.g. "drawable" or "color".
     */

    public static ResourceType fromFolderName(String folderName) {
        return CLASS_NAMES.get(folderName);
    }

    /**
     * Returns the enum by its name as it appears in XML as a tag name.
     *
     * @param tagName name of the XML tag, e.g. "string" or "declare-styleable".
     */

    public static ResourceType fromXmlTagName(String tagName) {
        return TAG_NAMES.get(tagName);
    }

    /**
     * Returns the enum by its name as it appears in a {@link ResourceUrl} string.
     *
     * @param xmlValue value of the type attribute or the prefix of a {@link ResourceUrl}, e.g.
     *                 "string" or "array".
     */

    public static ResourceType fromXmlValue(String xmlValue) {
        if (xmlValue.equals(SdkConstants.TAG_DECLARE_STYLEABLE)
            || xmlValue.equals(STYLEABLE.mName)) {
            return null;
        }

        if (xmlValue.equals(SAMPLE_DATA.mName)) {
            return SAMPLE_DATA;
        }

        return CLASS_NAMES.get(xmlValue);
    }

    public static <T> ResourceType fromXmlTag(
        T tag,
        Function<T, String> nameFunction,
        BiFunction<T, String, String> attributeFunction) {
        String tagName = nameFunction.apply(tag);
        switch (tagName) {
            case SdkConstants.TAG_EAT_COMMENT:
                return null;
            case SdkConstants.TAG_ITEM:
                String typeAttribute = attributeFunction.apply(tag, SdkConstants.ATTR_TYPE);
                if (!Strings.isNullOrEmpty(typeAttribute)) {
                    return fromClassName(typeAttribute);
                } else {
                    return null;
                }
            default:
                return fromXmlTagName(tagName);
        }
    }

    public static ResourceType fromXmlTag(Node domNode) {
        if (!(domNode instanceof Element)) {
            return null;
        }

        Element tag = (Element) domNode;
        return fromXmlTag(
            tag,
            element -> firstNonNull(element.getLocalName(), element.getTagName()),
            Element::getAttribute);
    }

    /**
     * @deprecated Use other static methods in this class. Kept for layoutlib binary compatibility.
     */
    @Deprecated
    public static ResourceType getEnum(String className) {
        return fromClassName(className);
    }

    /**
     * Returns true if the generated R class contains an inner class for this {@link ResourceType}.
     */
    public boolean getHasInnerClass() {
        return mKind != Kind.SYNTHETIC;
    }

    /**
     * Returns true if this {@link ResourceType} can be referenced using the {@link ResourceUrl}
     * syntax: {@code @typeName/resourceName}.
     */
    public boolean getCanBeReferenced() {
        return mKind == Kind.REAL && this != ATTR;
    }

    @Override
    public String toString() {
        // Unfortunately we still have code that relies on toString() returning the aapt name.
        return getName();
    }
}