1 /* 2 * Copyright (C) 2015 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #ifndef AAPT_RESOURCEUTILS_H 18 #define AAPT_RESOURCEUTILS_H 19 20 #include <functional> 21 #include <memory> 22 23 #include "androidfw/ResourceTypes.h" 24 #include "androidfw/StringPiece.h" 25 26 #include "NameMangler.h" 27 #include "Resource.h" 28 #include "ResourceValues.h" 29 #include "StringPool.h" 30 31 namespace aapt { 32 namespace ResourceUtils { 33 34 /** 35 * Returns true if the string was parsed as a resource name 36 * ([*][package:]type/name), with 37 * `out_resource` set to the parsed resource name and `out_private` set to true 38 * if a '*' prefix was present. 39 */ 40 bool ParseResourceName(const android::StringPiece& str, ResourceNameRef* out_resource, 41 bool* out_private = nullptr); 42 43 /* 44 * Returns true if the string was parsed as a reference 45 * (@[+][package:]type/name), with 46 * `out_reference` set to the parsed reference. 47 * 48 * If '+' was present in the reference, `out_create` is set to true. 49 * If '*' was present in the reference, `out_private` is set to true. 50 */ 51 bool ParseReference(const android::StringPiece& str, ResourceNameRef* out_reference, 52 bool* out_create = nullptr, bool* out_private = nullptr); 53 54 /* 55 * Returns true if the string is in the form of a resource reference 56 * (@[+][package:]type/name). 57 */ 58 bool IsReference(const android::StringPiece& str); 59 60 /* 61 * Returns true if the string was parsed as an attribute reference 62 * (?[package:][type/]name), 63 * with `out_reference` set to the parsed reference. 64 */ 65 bool ParseAttributeReference(const android::StringPiece& str, ResourceNameRef* out_reference); 66 67 /** 68 * Returns true if the string is in the form of an attribute 69 * reference(?[package:][type/]name). 70 */ 71 bool IsAttributeReference(const android::StringPiece& str); 72 73 /** 74 * Convert an android::ResTable::resource_name to an aapt::ResourceName struct. 75 */ 76 Maybe<ResourceName> ToResourceName( 77 const android::ResTable::resource_name& name); 78 79 /** 80 * Returns a boolean value if the string is equal to TRUE, true, True, FALSE, 81 * false, or False. 82 */ 83 Maybe<bool> ParseBool(const android::StringPiece& str); 84 85 /** 86 * Returns a uint32_t if the string is an integer. 87 */ 88 Maybe<uint32_t> ParseInt(const android::StringPiece& str); 89 90 /** 91 * Returns an ID if it the string represented a valid ID. 92 */ 93 Maybe<ResourceId> ParseResourceId(const android::StringPiece& str); 94 95 /** 96 * Parses an SDK version, which can be an integer, or a letter from A-Z. 97 */ 98 Maybe<int> ParseSdkVersion(const android::StringPiece& str); 99 100 /* 101 * Returns a Reference, or None Maybe instance if the string `str` was parsed as 102 * a 103 * valid reference to a style. 104 * The format for a style parent is slightly more flexible than a normal 105 * reference: 106 * 107 * @[package:]style/<entry> or 108 * ?[package:]style/<entry> or 109 * <package>:[style/]<entry> 110 */ 111 Maybe<Reference> ParseStyleParentReference(const android::StringPiece& str, std::string* out_error); 112 113 /* 114 * Returns a Reference if the string `str` was parsed as a valid XML attribute 115 * name. 116 * The valid format for an XML attribute name is: 117 * 118 * package:entry 119 */ 120 Maybe<Reference> ParseXmlAttributeName(const android::StringPiece& str); 121 122 /* 123 * Returns a Reference object if the string was parsed as a resource or 124 * attribute reference, 125 * ( @[+][package:]type/name | ?[package:]type/name ) setting outCreate to true 126 * if 127 * the '+' was present in the string. 128 */ 129 std::unique_ptr<Reference> TryParseReference(const android::StringPiece& str, 130 bool* out_create = nullptr); 131 132 /* 133 * Returns a BinaryPrimitve object representing @null or @empty if the string 134 * was parsed as one. 135 */ 136 std::unique_ptr<Item> TryParseNullOrEmpty(const android::StringPiece& str); 137 138 // Returns a Reference representing @null. 139 // Due to runtime compatibility issues, this is encoded as a reference with ID 0. 140 // The runtime will convert this to TYPE_NULL. 141 std::unique_ptr<Reference> MakeNull(); 142 143 // Returns a BinaryPrimitive representing @empty. This is encoded as a Res_value with 144 // type Res_value::TYPE_NULL and data Res_value::DATA_NULL_EMPTY. 145 std::unique_ptr<BinaryPrimitive> MakeEmpty(); 146 147 /* 148 * Returns a BinaryPrimitve object representing a color if the string was parsed 149 * as one. 150 */ 151 std::unique_ptr<BinaryPrimitive> TryParseColor(const android::StringPiece& str); 152 153 /* 154 * Returns a BinaryPrimitve object representing a boolean if the string was 155 * parsed as one. 156 */ 157 std::unique_ptr<BinaryPrimitive> TryParseBool(const android::StringPiece& str); 158 159 // Returns a boolean BinaryPrimitive. 160 std::unique_ptr<BinaryPrimitive> MakeBool(bool val); 161 162 /* 163 * Returns a BinaryPrimitve object representing an integer if the string was 164 * parsed as one. 165 */ 166 std::unique_ptr<BinaryPrimitive> TryParseInt(const android::StringPiece& str); 167 168 /* 169 * Returns a BinaryPrimitve object representing a floating point number 170 * (float, dimension, etc) if the string was parsed as one. 171 */ 172 std::unique_ptr<BinaryPrimitive> TryParseFloat(const android::StringPiece& str); 173 174 /* 175 * Returns a BinaryPrimitve object representing an enum symbol if the string was 176 * parsed as one. 177 */ 178 std::unique_ptr<BinaryPrimitive> TryParseEnumSymbol(const Attribute* enum_attr, 179 const android::StringPiece& str); 180 181 /* 182 * Returns a BinaryPrimitve object representing a flag symbol if the string was 183 * parsed as one. 184 */ 185 std::unique_ptr<BinaryPrimitive> TryParseFlagSymbol(const Attribute* enum_attr, 186 const android::StringPiece& str); 187 /* 188 * Try to convert a string to an Item for the given attribute. The attribute 189 * will 190 * restrict what values the string can be converted to. 191 * The callback function on_create_reference is called when the parsed item is a 192 * reference to an ID that must be created (@+id/foo). 193 */ 194 std::unique_ptr<Item> TryParseItemForAttribute( 195 const android::StringPiece& value, const Attribute* attr, 196 const std::function<void(const ResourceName&)>& on_create_reference = {}); 197 198 std::unique_ptr<Item> TryParseItemForAttribute( 199 const android::StringPiece& value, uint32_t type_mask, 200 const std::function<void(const ResourceName&)>& on_create_reference = {}); 201 202 uint32_t AndroidTypeToAttributeTypeMask(uint16_t type); 203 204 /** 205 * Returns a string path suitable for use within an APK. The path will look 206 * like: 207 * 208 * res/type[-config]/<name>.<ext> 209 * 210 * Then name may be mangled if a NameMangler is supplied (can be nullptr) and 211 * the package 212 * requires mangling. 213 */ 214 std::string BuildResourceFileName(const ResourceFile& res_file, 215 const NameMangler* mangler = nullptr); 216 217 // Parses the binary form of a resource value. `type` is used as a hint to know when a value is 218 // an ID versus a False boolean value, etc. `config` is for sorting strings in the string pool. 219 std::unique_ptr<Item> ParseBinaryResValue(const ResourceType& type, const ConfigDescription& config, 220 const android::ResStringPool& src_pool, 221 const android::Res_value& res_value, 222 StringPool* dst_pool); 223 224 } // namespace ResourceUtils 225 } // namespace aapt 226 227 #endif /* AAPT_RESOURCEUTILS_H */ 228