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_RESOURCE_H 18 #define AAPT_RESOURCE_H 19 20 #include <iomanip> 21 #include <limits> 22 #include <sstream> 23 #include <string> 24 #include <tuple> 25 #include <vector> 26 27 #include "androidfw/StringPiece.h" 28 #include "utils/JenkinsHash.h" 29 30 #include "ConfigDescription.h" 31 #include "Source.h" 32 33 namespace aapt { 34 35 /** 36 * The various types of resource types available. Corresponds 37 * to the 'type' in package:type/entry. 38 */ 39 enum class ResourceType { 40 kAnim, 41 kAnimator, 42 kArray, 43 kAttr, 44 kAttrPrivate, 45 kBool, 46 kColor, 47 48 // Not really a type, but it shows up in some CTS tests and 49 // we need to continue respecting it. 50 kConfigVarying, 51 52 kDimen, 53 kDrawable, 54 kFont, 55 kFraction, 56 kId, 57 kInteger, 58 kInterpolator, 59 kLayout, 60 kMenu, 61 kMipmap, 62 kPlurals, 63 kRaw, 64 kString, 65 kStyle, 66 kStyleable, 67 kTransition, 68 kXml, 69 }; 70 71 android::StringPiece ToString(ResourceType type); 72 73 /** 74 * Returns a pointer to a valid ResourceType, or nullptr if 75 * the string was invalid. 76 */ 77 const ResourceType* ParseResourceType(const android::StringPiece& str); 78 79 /** 80 * A resource's name. This can uniquely identify 81 * a resource in the ResourceTable. 82 */ 83 struct ResourceName { 84 std::string package; 85 ResourceType type = ResourceType::kRaw; 86 std::string entry; 87 88 ResourceName() = default; 89 ResourceName(const android::StringPiece& p, ResourceType t, const android::StringPiece& e); 90 91 int compare(const ResourceName& other) const; 92 93 bool is_valid() const; 94 std::string ToString() const; 95 }; 96 97 /** 98 * Same as ResourceName, but uses StringPieces instead. 99 * Use this if you need to avoid copying and know that 100 * the lifetime of this object is shorter than that 101 * of the original string. 102 */ 103 struct ResourceNameRef { 104 android::StringPiece package; 105 ResourceType type = ResourceType::kRaw; 106 android::StringPiece entry; 107 108 ResourceNameRef() = default; 109 ResourceNameRef(const ResourceNameRef&) = default; 110 ResourceNameRef(ResourceNameRef&&) = default; 111 ResourceNameRef(const ResourceName& rhs); // NOLINT(implicit) 112 ResourceNameRef(const android::StringPiece& p, ResourceType t, const android::StringPiece& e); 113 ResourceNameRef& operator=(const ResourceNameRef& rhs) = default; 114 ResourceNameRef& operator=(ResourceNameRef&& rhs) = default; 115 ResourceNameRef& operator=(const ResourceName& rhs); 116 117 ResourceName ToResourceName() const; 118 bool is_valid() const; 119 }; 120 121 constexpr const uint8_t kAppPackageId = 0x7fu; 122 constexpr const uint8_t kFrameworkPackageId = 0x01u; 123 124 /** 125 * A binary identifier representing a resource. Internally it 126 * is a 32bit integer split as follows: 127 * 128 * 0xPPTTEEEE 129 * 130 * PP: 8 bit package identifier. 0x01 is reserved for system 131 * and 0x7f is reserved for the running app. 132 * TT: 8 bit type identifier. 0x00 is invalid. 133 * EEEE: 16 bit entry identifier. 134 */ 135 struct ResourceId { 136 uint32_t id; 137 138 ResourceId(); 139 ResourceId(const ResourceId& rhs); 140 ResourceId(uint32_t res_id); // NOLINT(implicit) 141 ResourceId(uint8_t p, uint8_t t, uint16_t e); 142 143 bool is_valid() const; 144 145 // Returns true if the ID is a valid ID or dynamic ID (package ID can be 0). 146 bool is_valid_dynamic() const; 147 148 uint8_t package_id() const; 149 uint8_t type_id() const; 150 uint16_t entry_id() const; 151 }; 152 153 struct SourcedResourceName { 154 ResourceName name; 155 size_t line; 156 }; 157 158 struct ResourceFile { 159 // Name 160 ResourceName name; 161 162 // Configuration 163 ConfigDescription config; 164 165 // Source 166 Source source; 167 168 // Exported symbols 169 std::vector<SourcedResourceName> exported_symbols; 170 }; 171 172 /** 173 * Useful struct used as a key to represent a unique resource in associative 174 * containers. 175 */ 176 struct ResourceKey { 177 ResourceName name; 178 ConfigDescription config; 179 }; 180 181 bool operator<(const ResourceKey& a, const ResourceKey& b); 182 183 /** 184 * Useful struct used as a key to represent a unique resource in associative 185 * containers. 186 * Holds a reference to the name, so that name better live longer than this key! 187 */ 188 struct ResourceKeyRef { 189 ResourceNameRef name; 190 ConfigDescription config; 191 192 ResourceKeyRef() = default; 193 ResourceKeyRef(const ResourceNameRef& n, const ConfigDescription& c) 194 : name(n), config(c) {} 195 196 /** 197 * Prevent taking a reference to a temporary. This is bad. 198 */ 199 ResourceKeyRef(ResourceName&& n, const ConfigDescription& c) = delete; 200 }; 201 202 bool operator<(const ResourceKeyRef& a, const ResourceKeyRef& b); 203 204 // 205 // ResourceId implementation. 206 // 207 208 inline ResourceId::ResourceId() : id(0) {} 209 210 inline ResourceId::ResourceId(const ResourceId& rhs) : id(rhs.id) {} 211 212 inline ResourceId::ResourceId(uint32_t res_id) : id(res_id) {} 213 214 inline ResourceId::ResourceId(uint8_t p, uint8_t t, uint16_t e) 215 : id((p << 24) | (t << 16) | e) {} 216 217 inline bool ResourceId::is_valid() const { 218 return (id & 0xff000000u) != 0 && (id & 0x00ff0000u) != 0; 219 } 220 221 inline bool ResourceId::is_valid_dynamic() const { return (id & 0x00ff0000u) != 0; } 222 223 inline uint8_t ResourceId::package_id() const { 224 return static_cast<uint8_t>(id >> 24); 225 } 226 227 inline uint8_t ResourceId::type_id() const { 228 return static_cast<uint8_t>(id >> 16); 229 } 230 231 inline uint16_t ResourceId::entry_id() const { 232 return static_cast<uint16_t>(id); 233 } 234 235 inline bool operator<(const ResourceId& lhs, const ResourceId& rhs) { 236 return lhs.id < rhs.id; 237 } 238 239 inline bool operator>(const ResourceId& lhs, const ResourceId& rhs) { 240 return lhs.id > rhs.id; 241 } 242 243 inline bool operator==(const ResourceId& lhs, const ResourceId& rhs) { 244 return lhs.id == rhs.id; 245 } 246 247 inline bool operator!=(const ResourceId& lhs, const ResourceId& rhs) { 248 return lhs.id != rhs.id; 249 } 250 251 inline ::std::ostream& operator<<(::std::ostream& out, 252 const ResourceId& res_id) { 253 std::ios_base::fmtflags old_flags = out.flags(); 254 char old_fill = out.fill(); 255 out << "0x" << std::internal << std::setfill('0') << std::setw(8) << std::hex 256 << res_id.id; 257 out.flags(old_flags); 258 out.fill(old_fill); 259 return out; 260 } 261 262 // 263 // ResourceType implementation. 264 // 265 266 inline ::std::ostream& operator<<(::std::ostream& out, 267 const ResourceType& val) { 268 return out << ToString(val); 269 } 270 271 // 272 // ResourceName implementation. 273 // 274 275 inline ResourceName::ResourceName(const android::StringPiece& p, ResourceType t, 276 const android::StringPiece& e) 277 : package(p.to_string()), type(t), entry(e.to_string()) {} 278 279 inline int ResourceName::compare(const ResourceName& other) const { 280 int cmp = package.compare(other.package); 281 if (cmp != 0) return cmp; 282 cmp = static_cast<int>(type) - static_cast<int>(other.type); 283 if (cmp != 0) return cmp; 284 cmp = entry.compare(other.entry); 285 return cmp; 286 } 287 288 inline bool ResourceName::is_valid() const { 289 return !package.empty() && !entry.empty(); 290 } 291 292 inline bool operator<(const ResourceName& lhs, const ResourceName& rhs) { 293 return std::tie(lhs.package, lhs.type, lhs.entry) < 294 std::tie(rhs.package, rhs.type, rhs.entry); 295 } 296 297 inline bool operator==(const ResourceName& lhs, const ResourceName& rhs) { 298 return std::tie(lhs.package, lhs.type, lhs.entry) == 299 std::tie(rhs.package, rhs.type, rhs.entry); 300 } 301 302 inline bool operator!=(const ResourceName& lhs, const ResourceName& rhs) { 303 return std::tie(lhs.package, lhs.type, lhs.entry) != 304 std::tie(rhs.package, rhs.type, rhs.entry); 305 } 306 307 inline ::std::ostream& operator<<(::std::ostream& out, 308 const ResourceName& name) { 309 if (!name.package.empty()) { 310 out << name.package << ":"; 311 } 312 return out << name.type << "/" << name.entry; 313 } 314 315 inline std::string ResourceName::ToString() const { 316 std::stringstream stream; 317 stream << *this; 318 return stream.str(); 319 } 320 321 // 322 // ResourceNameRef implementation. 323 // 324 325 inline ResourceNameRef::ResourceNameRef(const ResourceName& rhs) 326 : package(rhs.package), type(rhs.type), entry(rhs.entry) {} 327 328 inline ResourceNameRef::ResourceNameRef(const android::StringPiece& p, ResourceType t, 329 const android::StringPiece& e) 330 : package(p), type(t), entry(e) {} 331 332 inline ResourceNameRef& ResourceNameRef::operator=(const ResourceName& rhs) { 333 package = rhs.package; 334 type = rhs.type; 335 entry = rhs.entry; 336 return *this; 337 } 338 339 inline ResourceName ResourceNameRef::ToResourceName() const { 340 return ResourceName(package, type, entry); 341 } 342 343 inline bool ResourceNameRef::is_valid() const { 344 return !package.empty() && !entry.empty(); 345 } 346 347 inline bool operator<(const ResourceNameRef& lhs, const ResourceNameRef& rhs) { 348 return std::tie(lhs.package, lhs.type, lhs.entry) < 349 std::tie(rhs.package, rhs.type, rhs.entry); 350 } 351 352 inline bool operator==(const ResourceNameRef& lhs, const ResourceNameRef& rhs) { 353 return std::tie(lhs.package, lhs.type, lhs.entry) == 354 std::tie(rhs.package, rhs.type, rhs.entry); 355 } 356 357 inline bool operator!=(const ResourceNameRef& lhs, const ResourceNameRef& rhs) { 358 return std::tie(lhs.package, lhs.type, lhs.entry) != 359 std::tie(rhs.package, rhs.type, rhs.entry); 360 } 361 362 inline ::std::ostream& operator<<(::std::ostream& out, 363 const ResourceNameRef& name) { 364 if (!name.package.empty()) { 365 out << name.package << ":"; 366 } 367 return out << name.type << "/" << name.entry; 368 } 369 370 inline bool operator<(const ResourceName& lhs, const ResourceNameRef& b) { 371 return ResourceNameRef(lhs) < b; 372 } 373 374 inline bool operator!=(const ResourceName& lhs, const ResourceNameRef& rhs) { 375 return ResourceNameRef(lhs) != rhs; 376 } 377 378 inline bool operator==(const SourcedResourceName& lhs, 379 const SourcedResourceName& rhs) { 380 return lhs.name == rhs.name && lhs.line == rhs.line; 381 } 382 383 } // namespace aapt 384 385 namespace std { 386 387 template <> 388 struct hash<aapt::ResourceName> { 389 size_t operator()(const aapt::ResourceName& name) const { 390 android::hash_t h = 0; 391 h = android::JenkinsHashMix(h, static_cast<uint32_t>(hash<string>()(name.package))); 392 h = android::JenkinsHashMix(h, static_cast<uint32_t>(name.type)); 393 h = android::JenkinsHashMix(h, static_cast<uint32_t>(hash<string>()(name.entry))); 394 return static_cast<size_t>(h); 395 } 396 }; 397 398 template <> 399 struct hash<aapt::ResourceId> { 400 size_t operator()(const aapt::ResourceId& id) const { 401 return id.id; 402 } 403 }; 404 405 } // namespace std 406 407 #endif // AAPT_RESOURCE_H 408
