| // Copyright 2018 The Bazel Authors. All rights reserved. | |
| // | |
| // 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 res handles understanding and representing information about Android resources. | |
| package res | |
| import ( | |
| "errors" | |
| "fmt" | |
| "strconv" | |
| "strings" | |
| rdpb "src/tools/ak/res/proto/res_data_go_proto" | |
| ) | |
| var ( | |
| // ErrWrongType occurs when a type is used in an operation that it does not support. | |
| ErrWrongType = errors.New("this type cannot be used in this operation") | |
| ) | |
| // Type of resource (eg: string, layout, drawable) | |
| type Type rdpb.Resource_Type | |
| // Enum converts a Type into a enum proto value | |
| func (t Type) Enum() (rdpb.Resource_Type, error) { | |
| if !t.IsSerializable() { | |
| return rdpb.Resource_Type(ValueType), ErrWrongType | |
| } | |
| return rdpb.Resource_Type(t), nil | |
| } | |
| // IsSerializable indicates that the Type can be converted to a proto (some types are only for in memory operations). | |
| func (t Type) IsSerializable() bool { | |
| for _, a := range nonProtoTypes { | |
| if t == a { | |
| return false | |
| } | |
| } | |
| return true | |
| } | |
| // NestedClassName is the R.java nested class name for this type (if the type is understood by android). | |
| func (t Type) NestedClassName() (string, error) { | |
| if !t.IsReal() { | |
| return "", ErrWrongType | |
| } | |
| return typeToString[t], nil | |
| } | |
| // IsReal indicates that the type is known to the android framework. | |
| func (t Type) IsReal() bool { | |
| for _, a := range nonProtoTypes { | |
| if a == t { | |
| return false | |
| } | |
| } | |
| return true | |
| } | |
| // From frameworks/base/tools/aapt2/Resource.h, except UnknownType and ValueType | |
| // TODO(mauriciogg): use proto definitions and remove ValueType and UnknownType. | |
| const ( | |
| // UnknownType needs to be zero value | |
| UnknownType Type = -2 | |
| ValueType = -1 | |
| // Anim represents Android Anim resource types. | |
| Anim = Type(rdpb.Resource_ANIM) | |
| // Animator represents Android Animator resource types. | |
| Animator = Type(rdpb.Resource_ANIMATOR) | |
| // Array represents Android Array resource types. | |
| Array = Type(rdpb.Resource_ARRAY) | |
| // Attr represents Android Attr resource types. | |
| Attr = Type(rdpb.Resource_ATTR) | |
| // AttrPrivate represents Android AttrPrivate resource types. | |
| AttrPrivate = Type(rdpb.Resource_ATTR_PRIVATE) | |
| // Bool represents Android Bool resource types. | |
| Bool = Type(rdpb.Resource_BOOL) | |
| // Color represents Android Color resource types. | |
| Color = Type(rdpb.Resource_COLOR) | |
| // ConfigVarying represents Android ConfigVarying resource types, not really a type, but it shows up in some CTS tests | |
| ConfigVarying = Type(rdpb.Resource_CONFIG_VARYING) | |
| // Dimen represents Android Dimen resource types. | |
| Dimen = Type(rdpb.Resource_DIMEN) | |
| // Drawable represents Android Drawable resource types. | |
| Drawable = Type(rdpb.Resource_DRAWABLE) | |
| // Font represents Android Font resource types. | |
| Font = Type(rdpb.Resource_FONT) | |
| // Fraction represents Android Fraction resource types. | |
| Fraction = Type(rdpb.Resource_FRACTION) | |
| // ID represents Android Id resource types. | |
| ID = Type(rdpb.Resource_ID) | |
| // Integer represents Android Integer resource types. | |
| Integer = Type(rdpb.Resource_INTEGER) | |
| // Interpolator represents Android Interpolator resource types. | |
| Interpolator = Type(rdpb.Resource_INTERPOLATOR) | |
| // Layout represents Android Layout resource types. | |
| Layout = Type(rdpb.Resource_LAYOUT) | |
| // Menu represents Android Menu resource types. | |
| Menu = Type(rdpb.Resource_MENU) | |
| // Mipmap represents Android Mipmap resource types. | |
| Mipmap = Type(rdpb.Resource_MIPMAP) | |
| // Navigation represents Android Navigation resource types. | |
| Navigation = Type(rdpb.Resource_NAVIGATION) | |
| // Plurals represents Android Plurals resource types. | |
| Plurals = Type(rdpb.Resource_PLURALS) | |
| // Raw represents Android Raw resource types. | |
| Raw = Type(rdpb.Resource_RAW) | |
| // String represents Android String resource types. | |
| String = Type(rdpb.Resource_STRING) | |
| // Style represents Android Style resource types. | |
| Style = Type(rdpb.Resource_STYLE) | |
| // Styleable represents Android Styleable resource types. | |
| Styleable = Type(rdpb.Resource_STYLEABLE) | |
| // Transition represents Android Transition resource types. | |
| Transition = Type(rdpb.Resource_TRANSITION) | |
| // XML represents Android Xml resource types. | |
| XML = Type(rdpb.Resource_XML) | |
| ) | |
| var ( | |
| // A fixed mapping between the string representation of a type and its Type. | |
| typeToString = map[Type]string{ | |
| Anim: "anim", | |
| Animator: "animator", | |
| Array: "array", | |
| Attr: "attr", | |
| AttrPrivate: "^attr-private", | |
| Bool: "bool", | |
| Color: "color", | |
| ConfigVarying: "configVarying", | |
| Dimen: "dimen", | |
| Drawable: "drawable", | |
| Fraction: "fraction", | |
| Font: "font", | |
| ID: "id", | |
| Integer: "integer", | |
| Interpolator: "interpolator", | |
| Layout: "layout", | |
| Menu: "menu", | |
| Mipmap: "mipmap", | |
| Navigation: "navigation", | |
| Plurals: "plurals", | |
| Raw: "raw", | |
| String: "string", | |
| Style: "style", | |
| Styleable: "styleable", | |
| Transition: "transition", | |
| XML: "xml", | |
| } | |
| stringToType = make(map[string]Type) | |
| // AllTypes is a list of all known resource types. | |
| AllTypes = make([]Type, 0, len(typeToString)) | |
| // These types are not allowed to be serialized into proto format. | |
| nonProtoTypes = []Type{ValueType, UnknownType} | |
| ) | |
| // Kind indicates what type of resource file emits this resource. A resource can be found in | |
| // res/values folder (and therefore is a Value - which can be represented as a ResourceValue in | |
| // Android) or in folders outside of res/values (such as res/layout) and thus are not ResourceValues | |
| // but rather some external resource (such as an image or parsed xml file). | |
| type Kind uint8 | |
| const ( | |
| // Unknown should not be encountered. | |
| Unknown Kind = iota | |
| // Value can only be encountered in res/values folders. | |
| Value | |
| // NonValue can not be encountered in res/values folders. | |
| NonValue | |
| // Both is a Kind of Type which may be inside a res/values folder or in another res/ folder. | |
| Both | |
| ) | |
| var ( | |
| kindToString = map[Kind]string{ | |
| Unknown: "Unknown", | |
| Value: "Value", | |
| NonValue: "NonValue", | |
| Both: "Both", | |
| } | |
| // A fixed mapping between Type and Kind. | |
| TypesToKind = map[Type]Kind{ | |
| Anim: NonValue, | |
| Animator: NonValue, | |
| Array: Value, | |
| Attr: Value, | |
| AttrPrivate: Value, | |
| Bool: Value, | |
| Color: Both, | |
| ConfigVarying: Value, | |
| Dimen: Value, | |
| Drawable: NonValue, | |
| Font: NonValue, | |
| Fraction: Value, | |
| ID: Value, | |
| Integer: Value, | |
| Interpolator: NonValue, | |
| Layout: NonValue, | |
| Menu: NonValue, | |
| Mipmap: NonValue, | |
| Navigation: NonValue, | |
| Plurals: Value, | |
| Raw: NonValue, | |
| String: Value, | |
| Style: Value, | |
| Styleable: Value, | |
| Transition: NonValue, | |
| XML: NonValue, | |
| } | |
| ) | |
| // Density represents the dpi value of a resource. | |
| type Density uint16 | |
| // From frameworks/base/core/java/Android/content/res/Configuration.java | |
| const ( | |
| // UnspecifiedDensity is a default value indicating no dpi has been specified | |
| UnspecifiedDensity Density = 0 | |
| // LDPI has a dpi of 120 | |
| LDPI Density = 120 | |
| // MDPI has a dpi of 160 | |
| MDPI Density = 160 | |
| // TVDPI has a dpi of 213 | |
| TVDPI Density = 213 | |
| // HDPI has a dpi of 240 | |
| HDPI Density = 240 | |
| // XhDPI has a dpi of 320 | |
| XhDPI Density = 320 | |
| // XxhDPI has a dpi of 480 | |
| XxhDPI Density = 480 | |
| // XxxhDPI has a dpi of 640 | |
| XxxhDPI Density = 640 | |
| // AnyDPI indicates a resource which can be any dpi. | |
| AnyDPI Density = 0xfffe | |
| // NoDPI indicates the resources have no dpi constraints | |
| NoDPI Density = 0xffff | |
| dpiSuffix = "dpi" | |
| ) | |
| var ( | |
| densityToStr = map[Density]string{ | |
| LDPI: "ldpi", | |
| MDPI: "mdpi", | |
| TVDPI: "tvdpi", | |
| HDPI: "hdpi", | |
| XhDPI: "xhdpi", | |
| XxhDPI: "xxhdpi", | |
| XxxhDPI: "xxxhdpi", | |
| AnyDPI: "anydpi", | |
| NoDPI: "nodpi", | |
| } | |
| strToDensity = make(map[string]Density) | |
| ) | |
| // ParseValueOrType converts a string into a value type or well known type | |
| func ParseValueOrType(s string) (Type, error) { | |
| if s == "values" { | |
| return ValueType, nil | |
| } | |
| return ParseType(s) | |
| } | |
| // ParseType converts a string into a well known type | |
| func ParseType(s string) (Type, error) { | |
| if t, ok := stringToType[s]; ok { | |
| return t, nil | |
| } | |
| return UnknownType, fmt.Errorf("%s: unknown type", s) | |
| } | |
| // String for Type structs corresponds to the string format known to Android. | |
| func (t Type) String() string { | |
| if s, ok := typeToString[t]; ok { | |
| return s | |
| } | |
| return fmt.Sprintf("Type(%d)", t) | |
| } | |
| // Kind indicates the resource kind of this type. | |
| func (t Type) Kind() Kind { | |
| if t == ValueType { | |
| return Value | |
| } | |
| if t, ok := TypesToKind[t]; ok { | |
| return t | |
| } | |
| return Unknown | |
| } | |
| // ParseDensity converts a string representation of a density into a Density. | |
| func ParseDensity(s string) (Density, error) { | |
| if d, ok := strToDensity[s]; ok { | |
| return d, nil | |
| } | |
| if strings.HasSuffix(s, dpiSuffix) { | |
| parsed, err := strconv.ParseUint(s[0:len(s)-len(dpiSuffix)], 10, 16) | |
| if err != nil { | |
| return 0, fmt.Errorf("%s: unparsable: %v", s, err) | |
| } | |
| return Density(parsed), nil | |
| } | |
| return UnspecifiedDensity, nil | |
| } | |
| func init() { | |
| for k, v := range typeToString { | |
| AllTypes = append(AllTypes, k) | |
| stringToType[v] = k | |
| } | |
| for k, v := range densityToStr { | |
| strToDensity[v] = k | |
| } | |
| } |