Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit cff10cec authored by Iurii Makhno's avatar Iurii Makhno
Browse files

Switch ResourceName to use ResourceNamedType instead of ResourceType. 

DD: go/custom-resource-types-in-aapt2

Bug: b/215108200
Test: Resource_test.cpp
Change-Id: I0b97fc0024523700e01adce788bb934d388da288
parent dfbac39d

tools/aapt2/Debug.cpp

+1 −1
Original line number Diff line number Diff line
@@ -80,7 +80,7 @@ class ValueHeadlinePrinter : public ConstValueVisitor { 
          printer_->Print(parent_name.package);

          printer_->Print(":");

        }

        printer_->Print(to_string(parent_name.type));

        printer_->Print(parent_name.type.to_string());

        printer_->Print("/");

        printer_->Print(parent_name.entry);

        if (parent_ref.id) {

tools/aapt2/Resource.h

+23 −6
Original line number Diff line number Diff line
@@ -128,10 +128,12 @@ std::optional<ResourceNamedTypeRef> ParseResourceNamedType(const android::String 
 */

struct ResourceName {

  std::string package;

  ResourceType type = ResourceType::kRaw;

  ResourceNamedType type;

  std::string entry;



  ResourceName() = default;

  ResourceName(const android::StringPiece& p, const ResourceNamedTypeRef& t,

               const android::StringPiece& e);

  ResourceName(const android::StringPiece& p, ResourceType t, const android::StringPiece& e);



  int compare(const ResourceName& other) const;
@@ -148,13 +150,15 @@ struct ResourceName { 
 */

struct ResourceNameRef {

  android::StringPiece package;

  ResourceType type = ResourceType::kRaw;

  ResourceNamedTypeRef type;

  android::StringPiece entry;



  ResourceNameRef() = default;

  ResourceNameRef(const ResourceNameRef&) = default;

  ResourceNameRef(ResourceNameRef&&) = default;

  ResourceNameRef(const ResourceName& rhs);  // NOLINT(google-explicit-constructor)

  ResourceNameRef(const android::StringPiece& p, const ResourceNamedTypeRef& t,

                  const android::StringPiece& e);

  ResourceNameRef(const android::StringPiece& p, ResourceType t, const android::StringPiece& e);

  ResourceNameRef& operator=(const ResourceNameRef& rhs) = default;

  ResourceNameRef& operator=(ResourceNameRef&& rhs) = default;
@@ -418,14 +422,20 @@ inline ::std::ostream& operator<<(::std::ostream& out, const ResourceNamedTypeRe 
// ResourceName implementation.

//



inline ResourceName::ResourceName(const android::StringPiece& p, const ResourceNamedTypeRef& t,

                                  const android::StringPiece& e)

    : package(p.to_string()), type(t.ToResourceNamedType()), entry(e.to_string()) {

}



inline ResourceName::ResourceName(const android::StringPiece& p, ResourceType t,

                                  const android::StringPiece& e)

    : package(p.to_string()), type(t), entry(e.to_string()) {}

    : ResourceName(p, ResourceNamedTypeWithDefaultName(t), e) {

}



inline int ResourceName::compare(const ResourceName& other) const {

  int cmp = package.compare(other.package);

  if (cmp != 0) return cmp;

  cmp = static_cast<int>(type) - static_cast<int>(other.type);

  cmp = type.compare(other.type);

  if (cmp != 0) return cmp;

  cmp = entry.compare(other.entry);

  return cmp;
@@ -461,9 +471,16 @@ inline ::std::ostream& operator<<(::std::ostream& out, const ResourceName& name) 
inline ResourceNameRef::ResourceNameRef(const ResourceName& rhs)

    : package(rhs.package), type(rhs.type), entry(rhs.entry) {}



inline ResourceNameRef::ResourceNameRef(const android::StringPiece& p,

                                        const ResourceNamedTypeRef& t,

                                        const android::StringPiece& e)

    : package(p), type(t), entry(e) {

}



inline ResourceNameRef::ResourceNameRef(const android::StringPiece& p, ResourceType t,

                                        const android::StringPiece& e)

    : package(p), type(t), entry(e) {}

    : ResourceNameRef(p, ResourceNamedTypeWithDefaultName(t), e) {

}



inline ResourceNameRef& ResourceNameRef::operator=(const ResourceName& rhs) {

  package = rhs.package;
@@ -520,7 +537,7 @@ struct hash<aapt::ResourceName> { 
  size_t operator()(const aapt::ResourceName& name) const {

    android::hash_t h = 0;

    h = android::JenkinsHashMix(h, static_cast<uint32_t>(hash<string>()(name.package)));

    h = android::JenkinsHashMix(h, static_cast<uint32_t>(name.type));

    h = android::JenkinsHashMix(h, static_cast<uint32_t>(hash<string>()(name.type.name)));

    h = android::JenkinsHashMix(h, static_cast<uint32_t>(hash<string>()(name.entry)));

    return static_cast<size_t>(h);

  }

tools/aapt2/ResourceParser.cpp

+31 −22
Original line number Diff line number Diff line
@@ -604,7 +604,8 @@ bool ResourceParser::ParseResource(xml::XmlPullParser* parser, 
      return false;

    }



    out_resource->name.type = ResourceType::kId;

    out_resource->name.type =

        ResourceNamedTypeWithDefaultName(ResourceType::kId).ToResourceNamedType();

    out_resource->name.entry = maybe_name.value().to_string();



    // Ids either represent a unique resource id or reference another resource id
@@ -623,7 +624,7 @@ bool ResourceParser::ParseResource(xml::XmlPullParser* parser, 
        // A null reference also means there is no inner element when ids are in the form:

        //    <id name="name"/>

        out_resource->value = util::make_unique<Id>();

      } else if (!ref || ref->name.value().type != ResourceType::kId) {

      } else if (!ref || ref->name.value().type.type != ResourceType::kId) {

        // If an inner element exists, the inner element must be a reference to another resource id

        diag_->Error(DiagMessage(out_resource->source)

                         << "<" << parser->element_name()
@@ -640,7 +641,8 @@ bool ResourceParser::ParseResource(xml::XmlPullParser* parser, 
      return false;

    }



    out_resource->name.type = ResourceType::kMacro;

    out_resource->name.type =

        ResourceNamedTypeWithDefaultName(ResourceType::kMacro).ToResourceNamedType();

    out_resource->name.entry = maybe_name.value().to_string();

    return ParseMacro(parser, out_resource);

  }
@@ -656,7 +658,8 @@ bool ResourceParser::ParseResource(xml::XmlPullParser* parser, 
        return false;

      }



      out_resource->name.type = item_iter->second.type;

      out_resource->name.type =

          ResourceNamedTypeWithDefaultName(item_iter->second.type).ToResourceNamedType();

      out_resource->name.entry = maybe_name.value().to_string();



      // Only use the implied format of the type when there is no explicit format.
@@ -699,7 +702,7 @@ bool ResourceParser::ParseResource(xml::XmlPullParser* parser, 
  if (can_be_item) {

    // Try parsing the elementName (or type) as a resource. These shall only be

    // resources like 'layout' or 'xml' and they can only be references.

    const ResourceType* parsed_type = ParseResourceType(resource_type);

    std::optional<ResourceNamedTypeRef> parsed_type = ParseResourceNamedType(resource_type);

    if (parsed_type) {

      if (!maybe_name) {

        diag_->Error(DiagMessage(out_resource->source)
@@ -708,7 +711,7 @@ bool ResourceParser::ParseResource(xml::XmlPullParser* parser, 
        return false;

      }



      out_resource->name.type = *parsed_type;

      out_resource->name.type = parsed_type->ToResourceNamedType();

      out_resource->name.entry = maybe_name.value().to_string();

      out_resource->value = ParseXml(parser, android::ResTable_map::TYPE_REFERENCE, kNoRawString);

      if (!out_resource->value) {
@@ -933,7 +936,7 @@ bool ResourceParser::ParsePublic(xml::XmlPullParser* parser, ParsedResource* out 
    return false;

  }



  const ResourceType* parsed_type = ParseResourceType(maybe_type.value());

  std::optional<ResourceNamedTypeRef> parsed_type = ParseResourceNamedType(maybe_type.value());

  if (!parsed_type) {

    diag_->Error(DiagMessage(out_resource->source) << "invalid resource type '"

                                                   << maybe_type.value()
@@ -941,7 +944,7 @@ bool ResourceParser::ParsePublic(xml::XmlPullParser* parser, ParsedResource* out 
    return false;

  }



  out_resource->name.type = *parsed_type;

  out_resource->name.type = parsed_type->ToResourceNamedType();



  if (std::optional<StringPiece> maybe_id_str = xml::FindNonEmptyAttribute(parser, "id")) {

    std::optional<ResourceId> maybe_id = ResourceUtils::ParseResourceId(maybe_id_str.value());
@@ -953,7 +956,7 @@ bool ResourceParser::ParsePublic(xml::XmlPullParser* parser, ParsedResource* out 
    out_resource->id = maybe_id.value();

  }



  if (*parsed_type == ResourceType::kId) {

  if (parsed_type->type == ResourceType::kId) {

    // An ID marked as public is also the definition of an ID.

    out_resource->value = util::make_unique<Id>();

  }
@@ -978,7 +981,7 @@ bool static ParseGroupImpl(xml::XmlPullParser* parser, ParsedResource* out_resou 
    return false;

  }



  const ResourceType* parsed_type = ParseResourceType(maybe_type.value());

  std::optional<ResourceNamedTypeRef> parsed_type = ParseResourceNamedType(maybe_type.value());

  if (!parsed_type) {

    diag->Error(DiagMessage(out_resource->source)

                << "invalid resource type '" << maybe_type.value() << "' in <" << tag_name << ">");
@@ -1096,7 +1099,7 @@ bool ResourceParser::ParseSymbolImpl(xml::XmlPullParser* parser, 
    return false;

  }



  const ResourceType* parsed_type = ParseResourceType(maybe_type.value());

  std::optional<ResourceNamedTypeRef> parsed_type = ParseResourceNamedType(maybe_type.value());

  if (!parsed_type) {

    diag_->Error(DiagMessage(out_resource->source)

                 << "invalid resource type '" << maybe_type.value() << "' in <"
@@ -1104,7 +1107,7 @@ bool ResourceParser::ParseSymbolImpl(xml::XmlPullParser* parser, 
    return false;

  }



  out_resource->name.type = *parsed_type;

  out_resource->name.type = parsed_type->ToResourceNamedType();

  return true;

}
@@ -1208,8 +1211,8 @@ bool ResourceParser::ParseOverlayable(xml::XmlPullParser* parser, ParsedResource 
        continue;

      }



      const ResourceType* type = ParseResourceType(item_type.value());

      if (type == nullptr) {

      std::optional<ResourceNamedTypeRef> type = ParseResourceNamedType(item_type.value());

      if (!type) {

        diag_->Error(DiagMessage(element_source)

                     << "invalid resource type '" << item_type.value()

                     << "' in <item> within an <overlayable>");
@@ -1223,7 +1226,7 @@ bool ResourceParser::ParseOverlayable(xml::XmlPullParser* parser, ParsedResource 
      overlayable_item.source = element_source;



      ParsedResource child_resource{};

      child_resource.name.type = *type;

      child_resource.name.type = type->ToResourceNamedType();

      child_resource.name.entry = item_name.value().to_string();

      child_resource.overlayable_item = overlayable_item;

      out_resource->child_resources.push_back(std::move(child_resource));
@@ -1289,7 +1292,8 @@ bool ResourceParser::ParseAttr(xml::XmlPullParser* parser, 


bool ResourceParser::ParseAttrImpl(xml::XmlPullParser* parser,

                                   ParsedResource* out_resource, bool weak) {

  out_resource->name.type = ResourceType::kAttr;

  out_resource->name.type =

      ResourceNamedTypeWithDefaultName(ResourceType::kAttr).ToResourceNamedType();



  // Attributes only end up in default configuration.

  if (out_resource->config != ConfigDescription::DefaultConfig()) {
@@ -1475,7 +1479,8 @@ std::optional<Attribute::Symbol> ResourceParser::ParseEnumOrFlagItem(xml::XmlPul 
  }



  return Attribute::Symbol{

      Reference(ResourceNameRef({}, ResourceType::kId, maybe_name.value())),

      Reference(ResourceNameRef({}, ResourceNamedTypeWithDefaultName(ResourceType::kId),

                                maybe_name.value())),

      val.data, val.dataType};

}
@@ -1509,7 +1514,7 @@ bool ResourceParser::ParseStyleItem(xml::XmlPullParser* parser, Style* style) { 


bool ResourceParser::ParseStyle(const ResourceType type, xml::XmlPullParser* parser,

                                ParsedResource* out_resource) {

  out_resource->name.type = type;

  out_resource->name.type = ResourceNamedTypeWithDefaultName(type).ToResourceNamedType();



  std::unique_ptr<Style> style = util::make_unique<Style>();
@@ -1535,7 +1540,8 @@ bool ResourceParser::ParseStyle(const ResourceType type, xml::XmlPullParser* par 
    size_t pos = style_name.find_last_of(u'.');

    if (pos != std::string::npos) {

      style->parent_inferred = true;

      style->parent = Reference(ResourceName({}, ResourceType::kStyle, style_name.substr(0, pos)));

      style->parent = Reference(ResourceName(

          {}, ResourceNamedTypeWithDefaultName(ResourceType::kStyle), style_name.substr(0, pos)));

    }

  }
@@ -1591,7 +1597,8 @@ bool ResourceParser::ParseStringArray(xml::XmlPullParser* parser, ParsedResource 
bool ResourceParser::ParseArrayImpl(xml::XmlPullParser* parser,

                                    ParsedResource* out_resource,

                                    const uint32_t typeMask) {

  out_resource->name.type = ResourceType::kArray;

  out_resource->name.type =

      ResourceNamedTypeWithDefaultName(ResourceType::kArray).ToResourceNamedType();



  std::unique_ptr<Array> array = util::make_unique<Array>();
@@ -1646,7 +1653,8 @@ bool ResourceParser::ParseArrayImpl(xml::XmlPullParser* parser, 


bool ResourceParser::ParsePlural(xml::XmlPullParser* parser,

                                 ParsedResource* out_resource) {

  out_resource->name.type = ResourceType::kPlurals;

  out_resource->name.type =

      ResourceNamedTypeWithDefaultName(ResourceType::kPlurals).ToResourceNamedType();



  std::unique_ptr<Plural> plural = util::make_unique<Plural>();
@@ -1727,7 +1735,8 @@ bool ResourceParser::ParsePlural(xml::XmlPullParser* parser, 


bool ResourceParser::ParseDeclareStyleable(xml::XmlPullParser* parser,

                                           ParsedResource* out_resource) {

  out_resource->name.type = ResourceType::kStyleable;

  out_resource->name.type =

      ResourceNamedTypeWithDefaultName(ResourceType::kStyleable).ToResourceNamedType();



  if (!options_.preserve_visibility_of_styleables) {

    // This was added in change Idd21b5de4d20be06c6f8c8eb5a22ccd68afc4927 to mimic aapt1, but no one

tools/aapt2/ResourceTable.cpp

+4 −4
Original line number Diff line number Diff line
@@ -473,7 +473,7 @@ bool ResourceTable::AddResource(NewResource&& res, IDiagnostics* diag) { 
  }



  auto package = FindOrCreatePackage(res.name.package);

  auto type = package->FindOrCreateType(res.name.type);

  auto type = package->FindOrCreateType(res.name.type.type);

  auto entry_it = std::equal_range(type->entries.begin(), type->entries.end(), res.name.entry,

                                   NameEqualRange<ResourceEntry>{});

  const size_t entry_count = std::distance(entry_it.first, entry_it.second);
@@ -593,7 +593,7 @@ std::optional<ResourceTable::SearchResult> ResourceTable::FindResource( 
    return {};

  }



  ResourceTableType* type = package->FindType(name.type);

  ResourceTableType* type = package->FindType(name.type.type);

  if (type == nullptr) {

    return {};

  }
@@ -612,7 +612,7 @@ std::optional<ResourceTable::SearchResult> ResourceTable::FindResource(const Res 
    return {};

  }



  ResourceTableType* type = package->FindType(name.type);

  ResourceTableType* type = package->FindType(name.type.type);

  if (type == nullptr) {

    return {};

  }
@@ -633,7 +633,7 @@ bool ResourceTable::RemoveResource(const ResourceNameRef& name, ResourceId id) c 
    return {};

  }



  ResourceTableType* type = package->FindType(name.type);

  ResourceTableType* type = package->FindType(name.type.type);

  if (type == nullptr) {

    return {};

  }

tools/aapt2/ResourceUtils.cpp

+15 −15
Original line number Diff line number Diff line
@@ -50,12 +50,11 @@ std::optional<ResourceName> ToResourceName(const android::ResTable::resource_nam 
  name_out.package =

      util::Utf16ToUtf8(StringPiece16(name_in.package, name_in.packageLen));



  const ResourceType* type;

  std::optional<ResourceNamedTypeRef> type;

  if (name_in.type) {

    type = ParseResourceType(

        util::Utf16ToUtf8(StringPiece16(name_in.type, name_in.typeLen)));

    type = ParseResourceNamedType(util::Utf16ToUtf8(StringPiece16(name_in.type, name_in.typeLen)));

  } else if (name_in.type8) {

    type = ParseResourceType(StringPiece(name_in.type8, name_in.typeLen));

    type = ParseResourceNamedType(StringPiece(name_in.type8, name_in.typeLen));

  } else {

    return {};

  }
@@ -64,7 +63,7 @@ std::optional<ResourceName> ToResourceName(const android::ResTable::resource_nam 
    return {};

  }



  name_out.type = *type;

  name_out.type = type->ToResourceNamedType();



  if (name_in.name) {

    name_out.entry =
@@ -85,12 +84,12 @@ std::optional<ResourceName> ToResourceName(const android::AssetManager2::Resourc 


  name_out.package = std::string(name_in.package, name_in.package_len);



  const ResourceType* type;

  std::optional<ResourceNamedTypeRef> type;

  if (name_in.type16) {

    type = ParseResourceType(

        util::Utf16ToUtf8(StringPiece16(name_in.type16, name_in.type_len)));

    type =

        ParseResourceNamedType(util::Utf16ToUtf8(StringPiece16(name_in.type16, name_in.type_len)));

  } else if (name_in.type) {

    type = ParseResourceType(StringPiece(name_in.type, name_in.type_len));

    type = ParseResourceNamedType(StringPiece(name_in.type, name_in.type_len));

  } else {

    return {};

  }
@@ -99,7 +98,7 @@ std::optional<ResourceName> ToResourceName(const android::AssetManager2::Resourc 
    return {};

  }



  name_out.type = *type;

  name_out.type = type->ToResourceNamedType();



  if (name_in.entry16) {

    name_out.entry =
@@ -133,7 +132,7 @@ bool ParseResourceName(const StringPiece& str, ResourceNameRef* out_ref, 
    return false;

  }



  const ResourceType* parsed_type = ParseResourceType(type);

  std::optional<ResourceNamedTypeRef> parsed_type = ParseResourceNamedType(type);

  if (!parsed_type) {

    return false;

  }
@@ -181,7 +180,7 @@ bool ParseReference(const StringPiece& str, ResourceNameRef* out_ref, 
      return false;

    }



    if (create && name.type != ResourceType::kId) {

    if (create && name.type.type != ResourceType::kId) {

      return false;

    }
@@ -230,7 +229,7 @@ bool ParseAttributeReference(const StringPiece& str, ResourceNameRef* out_ref) { 


    if (out_ref) {

      out_ref->package = package;

      out_ref->type = ResourceType::kAttr;

      out_ref->type = ResourceNamedTypeWithDefaultName(ResourceType::kAttr);

      out_ref->entry = entry;

    }

    return true;
@@ -272,7 +271,7 @@ std::optional<Reference> ParseStyleParentReference(const StringPiece& str, std:: 
  }



  ResourceNameRef ref;

  ref.type = ResourceType::kStyle;

  ref.type = ResourceNamedTypeWithDefaultName(ResourceType::kStyle);



  StringPiece type_str;

  android::ExtractResourceName(name, &ref.package, &type_str, &ref.entry);
@@ -323,7 +322,8 @@ std::optional<Reference> ParseXmlAttributeName(const StringPiece& str) { 
    p++;

  }



  ref.name = ResourceName(package, ResourceType::kAttr, name.empty() ? trimmed_str : name);

  ref.name = ResourceName(package, ResourceNamedTypeWithDefaultName(ResourceType::kAttr),

                          name.empty() ? trimmed_str : name);

  return std::optional<Reference>(std::move(ref));

}