libs/androidfw/AttributeResolution.cpp - LeafOS-Project/android_frameworks_base - Gitiles

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

 #include "androidfw/AttributeResolution.h"

 #include <cstdint>

 #include <log/log.h>

 #include "androidfw/AssetManager2.h"
 #include "androidfw/AttributeFinder.h"

 constexpr bool kDebugStyles = false;
 #define DEBUG_LOG(...) do { if (kDebugStyles) { ALOGI(__VA_ARGS__); } } while(0)

 namespace android {

 namespace {

 // Java asset cookies have 0 as an invalid cookie, but TypedArray expects < 0.
 static uint32_t ApkAssetsCookieToJavaCookie(ApkAssetsCookie cookie) {
   return cookie != kInvalidCookie ? static_cast<uint32_t>(cookie + 1) : static_cast<uint32_t>(-1);
 }

 class XmlAttributeFinder
     : public BackTrackingAttributeFinder<XmlAttributeFinder, size_t> {
  public:
   explicit XmlAttributeFinder(const ResXMLParser* parser)
       : BackTrackingAttributeFinder(0, parser != nullptr ? parser->getAttributeCount() : 0),
         parser_(parser) {}

   inline uint32_t GetAttribute(size_t index) const {
     return parser_->getAttributeNameResID(index);
   }

  private:
   const ResXMLParser* parser_;
 };

 class BagAttributeFinder
     : public BackTrackingAttributeFinder<BagAttributeFinder, const ResolvedBag::Entry*> {
  public:
   explicit BagAttributeFinder(const ResolvedBag* bag)
       : BackTrackingAttributeFinder(bag != nullptr ? bag->entries : nullptr,
                                     bag != nullptr ? bag->entries + bag->entry_count : nullptr) {
   }

   inline uint32_t GetAttribute(const ResolvedBag::Entry* entry) const {
     return entry->key;
   }
 };

 base::expected<const ResolvedBag*, NullOrIOError> GetStyleBag(Theme* theme,
                                                               uint32_t theme_attribute_resid,
                                                               uint32_t fallback_resid,
                                                               uint32_t* out_theme_flags) {
   // Load the style from the attribute if specified.
   if (theme_attribute_resid != 0U) {
     std::optional<AssetManager2::SelectedValue> value = theme->GetAttribute(theme_attribute_resid);
     if (value.has_value()) {
       *out_theme_flags |= value->flags;
       auto result = theme->GetAssetManager()->ResolveBag(*value);
       if (result.has_value() || IsIOError(result)) {
         return result;
       }
     }
   }

   // Fallback to loading the style from the resource id if specified.
   if (fallback_resid != 0U) {
     return theme->GetAssetManager()->GetBag(fallback_resid);
   }

   return base::unexpected(std::nullopt);
 }

 base::expected<const ResolvedBag*, NullOrIOError> GetXmlStyleBag(Theme* theme,
                                                                  ResXMLParser* xml_parser,
                                                                  uint32_t* out_theme_flags) {
   if (xml_parser == nullptr) {
     return base::unexpected(std::nullopt);
   }

   // Retrieve the style resource ID associated with the current XML tag's style attribute.
   Res_value value;
   const ssize_t idx = xml_parser->indexOfStyle();
   if (idx < 0 || xml_parser->getAttributeValue(idx, &value) < 0) {
     return base::unexpected(std::nullopt);
   }

   if (value.dataType == Res_value::TYPE_ATTRIBUTE) {
     // Resolve the attribute with out theme.
     if (std::optional<AssetManager2::SelectedValue> result = theme->GetAttribute(value.data)) {
       *out_theme_flags |= result->flags;
       return theme->GetAssetManager()->ResolveBag(*result);
     }
   }

   if (value.dataType == Res_value::TYPE_REFERENCE) {
     return theme->GetAssetManager()->GetBag(value.data);
   }

   return base::unexpected(std::nullopt);
 }

 } // namespace

 base::expected<std::monostate, IOError> ResolveAttrs(Theme* theme, uint32_t def_style_attr,
                                                      uint32_t def_style_res, uint32_t* src_values,
                                                      size_t src_values_length, uint32_t* attrs,
                                                      size_t attrs_length, uint32_t* out_values,
                                                      uint32_t* out_indices) {
   DEBUG_LOG("APPLY STYLE: theme=0x%p defStyleAttr=0x%x defStyleRes=0x%x", theme, def_style_attr,
             def_style_res);

   int indices_idx = 0;
   const AssetManager2* assetmanager = theme->GetAssetManager();

   // Load default style from attribute or resource id, if specified...
   uint32_t def_style_theme_flags = 0U;
   const auto default_style_bag = GetStyleBag(theme, def_style_attr, def_style_res,
                                              &def_style_theme_flags);
   if (UNLIKELY(IsIOError(default_style_bag))) {
     return base::unexpected(GetIOError(default_style_bag.error()));
   }

   BagAttributeFinder def_style_attr_finder(default_style_bag.value_or(nullptr));

   // Now iterate through all of the attributes that the client has requested,
   // filling in each with whatever data we can find.
   for (size_t ii = 0; ii < attrs_length; ii++) {
     const uint32_t cur_ident = attrs[ii];
     DEBUG_LOG("RETRIEVING ATTR 0x%08x...", cur_ident);

     // Try to find a value for this attribute...  we prioritize values
     // coming from, first XML attributes, then XML style, then default
     // style, and finally the theme.

     // Retrieve the current input value if available.
     AssetManager2::SelectedValue value{};
     if (src_values_length > 0 && src_values[ii] != 0) {
       value.type = Res_value::TYPE_ATTRIBUTE;
       value.data = src_values[ii];
       DEBUG_LOG("-> From values: type=0x%x, data=0x%08x", value.type, value.data);
     } else {
       const ResolvedBag::Entry* const entry = def_style_attr_finder.Find(cur_ident);
       if (entry != def_style_attr_finder.end()) {
         value = AssetManager2::SelectedValue(*default_style_bag, *entry);
         value.flags |= def_style_theme_flags;
         DEBUG_LOG("-> From def style: type=0x%x, data=0x%08x", value.type, value.data);
       }
     }

     if (value.type != Res_value::TYPE_NULL) {
       // Take care of resolving the found resource to its final value.
       const auto result = theme->ResolveAttributeReference(value);
       if (UNLIKELY(IsIOError(result))) {
         return base::unexpected(GetIOError(result.error()));
       }
       DEBUG_LOG("-> Resolved attr: type=0x%x, data=0x%08x", value.type, value.data);
     } else if (value.data != Res_value::DATA_NULL_EMPTY) {
       // If we still don't have a value for this attribute, try to find it in the theme!
       if (auto attr_value = theme->GetAttribute(cur_ident)) {
         value = *attr_value;
         DEBUG_LOG("-> From theme: type=0x%x, data=0x%08x", value.type, value.data);

         const auto result = assetmanager->ResolveReference(value, true /* cache_value */);
         if (UNLIKELY(IsIOError(result))) {
           return base::unexpected(GetIOError(result.error()));
         }
         DEBUG_LOG("-> Resolved theme: type=0x%x, data=0x%08x", value.type, value.data);
       }
     }

     // Deal with the special @null value -- it turns back to TYPE_NULL.
     if (value.type == Res_value::TYPE_REFERENCE && value.data == 0) {
       DEBUG_LOG("-> Setting to @null!");
       value.type = Res_value::TYPE_NULL;
       value.data = Res_value::DATA_NULL_UNDEFINED;
       value.cookie = kInvalidCookie;
     }

     DEBUG_LOG("Attribute 0x%08x: type=0x%x, data=0x%08x", cur_ident, value.type, value.data);

     // Write the final value back to Java.
     out_values[STYLE_TYPE] = value.type;
     out_values[STYLE_DATA] = value.data;
     out_values[STYLE_ASSET_COOKIE] = ApkAssetsCookieToJavaCookie(value.cookie);
     out_values[STYLE_RESOURCE_ID] = value.resid;
     out_values[STYLE_CHANGING_CONFIGURATIONS] = value.flags;
     out_values[STYLE_DENSITY] = value.config.density;

     if (out_indices != nullptr &&
         (value.type != Res_value::TYPE_NULL || value.data == Res_value::DATA_NULL_EMPTY)) {
       out_indices[++indices_idx] = ii;
     }

     out_values += STYLE_NUM_ENTRIES;
   }

   if (out_indices != nullptr) {
     out_indices[0] = indices_idx;
   }
   return {};
 }

 base::expected<std::monostate, IOError> ApplyStyle(Theme* theme, ResXMLParser* xml_parser,
                                                    uint32_t def_style_attr,
                                                    uint32_t def_style_resid,
                                                    const uint32_t* attrs, size_t attrs_length,
                                                    uint32_t* out_values, uint32_t* out_indices) {
   DEBUG_LOG("APPLY STYLE: theme=0x%p defStyleAttr=0x%x defStyleRes=0x%x xml=0x%p", theme,
             def_style_attr, def_style_resid, xml_parser);

   int indices_idx = 0;
   const AssetManager2* assetmanager = theme->GetAssetManager();

   // Load default style from attribute, if specified...
   uint32_t def_style_theme_flags = 0U;
   const auto default_style_bag = GetStyleBag(theme, def_style_attr, def_style_resid,
                                              &def_style_theme_flags);
   if (IsIOError(default_style_bag)) {
     return base::unexpected(GetIOError(default_style_bag.error()));
   }

   // Retrieve the style resource ID associated with the current XML tag's style attribute.
   uint32_t xml_style_theme_flags = 0U;
   const auto xml_style_bag = GetXmlStyleBag(theme, xml_parser, &def_style_theme_flags);
   if (IsIOError(xml_style_bag)) {
     return base::unexpected(GetIOError(xml_style_bag.error()));
   }

   BagAttributeFinder def_style_attr_finder(default_style_bag.value_or(nullptr));
   BagAttributeFinder xml_style_attr_finder(xml_style_bag.value_or(nullptr));
   XmlAttributeFinder xml_attr_finder(xml_parser);

   // Now iterate through all of the attributes that the client has requested,
   // filling in each with whatever data we can find.
   for (size_t ii = 0; ii < attrs_length; ii++) {
     const uint32_t cur_ident = attrs[ii];
     DEBUG_LOG("RETRIEVING ATTR 0x%08x...", cur_ident);

     AssetManager2::SelectedValue value{};
     uint32_t value_source_resid = 0;

     // Try to find a value for this attribute...  we prioritize values
     // coming from, first XML attributes, then XML style, then default
     // style, and finally the theme.

     // Walk through the xml attributes looking for the requested attribute.
     const size_t xml_attr_idx = xml_attr_finder.Find(cur_ident);
     if (xml_attr_idx != xml_attr_finder.end()) {
       // We found the attribute we were looking for.
       Res_value attribute_value{};
       xml_parser->getAttributeValue(xml_attr_idx, &attribute_value);
       value.type = attribute_value.dataType;
       value.data = attribute_value.data;
       value_source_resid = xml_parser->getSourceResourceId();
       DEBUG_LOG("-> From XML: type=0x%x, data=0x%08x", value.type, value.data);
     }

     if (value.type == Res_value::TYPE_NULL && value.data != Res_value::DATA_NULL_EMPTY) {
       // Walk through the style class values looking for the requested attribute.
       const ResolvedBag::Entry* entry = xml_style_attr_finder.Find(cur_ident);
       if (entry != xml_style_attr_finder.end()) {
         value = AssetManager2::SelectedValue(*xml_style_bag, *entry);
         value.flags |= xml_style_theme_flags;
         value_source_resid = entry->style;
         DEBUG_LOG("-> From style: type=0x%x, data=0x%08x, style=0x%08x", value.type, value.data,
                   value_source_resid);
       }
     }

     if (value.type == Res_value::TYPE_NULL && value.data != Res_value::DATA_NULL_EMPTY) {
       // Walk through the default style values looking for the requested attribute.
       const ResolvedBag::Entry* entry = def_style_attr_finder.Find(cur_ident);
       if (entry != def_style_attr_finder.end()) {
         value = AssetManager2::SelectedValue(*default_style_bag, *entry);
         value.flags |= def_style_theme_flags;
         value_source_resid = entry->style;
         DEBUG_LOG("-> From def style: type=0x%x, data=0x%08x, style=0x%08x", value.type, value.data,
                   entry->style);
       }
     }

     if (value.type != Res_value::TYPE_NULL) {
       // Take care of resolving the found resource to its final value.
       auto result = theme->ResolveAttributeReference(value);
       if (UNLIKELY(IsIOError(result))) {
         return base::unexpected(GetIOError(result.error()));
       }
       DEBUG_LOG("-> Resolved attr: type=0x%x, data=0x%08x", value.type, value.data);
     } else if (value.data != Res_value::DATA_NULL_EMPTY) {
       // If we still don't have a value for this attribute, try to find it in the theme!
       if (auto attr_value = theme->GetAttribute(cur_ident)) {
         value = *attr_value;
         DEBUG_LOG("-> From theme: type=0x%x, data=0x%08x", value.type, value.data);

         auto result = assetmanager->ResolveReference(value, true /* cache_value */);
         if (UNLIKELY(IsIOError(result))) {
           return base::unexpected(GetIOError(result.error()));
         }
         DEBUG_LOG("-> Resolved theme: type=0x%x, data=0x%08x", value.type, value.data);
         // TODO: set value_source_resid for the style in the theme that was used.
       }
     }

     // Deal with the special @null value -- it turns back to TYPE_NULL.
     if (value.type == Res_value::TYPE_REFERENCE && value.data == 0U) {
       DEBUG_LOG("-> Setting to @null!");
       value.type = Res_value::TYPE_NULL;
       value.data = Res_value::DATA_NULL_UNDEFINED;
       value.cookie = kInvalidCookie;
     }

     DEBUG_LOG("Attribute 0x%08x: type=0x%x, data=0x%08x", cur_ident, value.type, value.data);

     // Write the final value back to Java.
     out_values[STYLE_TYPE] = value.type;
     out_values[STYLE_DATA] = value.data;
     out_values[STYLE_ASSET_COOKIE] = ApkAssetsCookieToJavaCookie(value.cookie);
     out_values[STYLE_RESOURCE_ID] = value.resid;
     out_values[STYLE_CHANGING_CONFIGURATIONS] = value.flags;
     out_values[STYLE_DENSITY] = value.config.density;
     out_values[STYLE_SOURCE_RESOURCE_ID] = value_source_resid;

     if (value.type != Res_value::TYPE_NULL || value.data == Res_value::DATA_NULL_EMPTY) {
       // out_indices must NOT be nullptr.
       out_indices[++indices_idx] = ii;
     }
     out_values += STYLE_NUM_ENTRIES;
   }

   // out_indices must NOT be nullptr.
   out_indices[0] = indices_idx;
   return {};
 }

 base::expected<std::monostate, IOError> RetrieveAttributes(AssetManager2* assetmanager,
                                                            ResXMLParser* xml_parser,
                                                            uint32_t* attrs,
                                                            size_t attrs_length,
                                                            uint32_t* out_values,
                                                            uint32_t* out_indices) {
   int indices_idx = 0;

   // Retrieve the XML attributes, if requested.
   size_t ix = 0;
   const size_t xml_attr_count = xml_parser->getAttributeCount();
   uint32_t cur_xml_attr = xml_parser->getAttributeNameResID(ix);

   // Now iterate through all of the attributes that the client has requested,
   // filling in each with whatever data we can find.
   for (size_t ii = 0; ii < attrs_length; ii++) {
     const uint32_t cur_ident = attrs[ii];
      AssetManager2::SelectedValue value{};

     // Try to find a value for this attribute...
     // Skip through XML attributes until the end or the next possible match.
     while (ix < xml_attr_count && cur_ident > cur_xml_attr) {
       cur_xml_attr = xml_parser->getAttributeNameResID(++ix);
     }

     // Retrieve the current XML attribute if it matches, and step to next.
     if (ix < xml_attr_count && cur_ident == cur_xml_attr) {
       Res_value attribute_value{};
       xml_parser->getAttributeValue(ix, &attribute_value);
       value.type = attribute_value.dataType;
       value.data = attribute_value.data;
       cur_xml_attr = xml_parser->getAttributeNameResID(++ix);
     }

     if (value.type != Res_value::TYPE_NULL) {
       // Take care of resolving the found resource to its final value.
       auto result = assetmanager->ResolveReference(value);
       if (UNLIKELY(IsIOError(result))) {
         return base::unexpected(GetIOError(result.error()));
       }
     }

     // Deal with the special @null value -- it turns back to TYPE_NULL.
     if (value.type == Res_value::TYPE_REFERENCE && value.data == 0U) {
       value.type = Res_value::TYPE_NULL;
       value.data = Res_value::DATA_NULL_UNDEFINED;
       value.cookie = kInvalidCookie;
     }

     // Write the final value back to Java.
     out_values[STYLE_TYPE] = value.type;
     out_values[STYLE_DATA] = value.data;
     out_values[STYLE_ASSET_COOKIE] = ApkAssetsCookieToJavaCookie(value.cookie);
     out_values[STYLE_RESOURCE_ID] = value.resid;
     out_values[STYLE_CHANGING_CONFIGURATIONS] = value.flags;
     out_values[STYLE_DENSITY] = value.config.density;

     if (out_indices != nullptr &&
         (value.type != Res_value::TYPE_NULL ||
          value.data == Res_value::DATA_NULL_EMPTY)) {
       out_indices[++indices_idx] = ii;
     }

     out_values += STYLE_NUM_ENTRIES;
   }

   if (out_indices != nullptr) {
     out_indices[0] = indices_idx;
   }
   return {};
 }

 }  // namespace android
	/*
	* Copyright (C) 2016 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.
	*/

	#include "androidfw/AttributeResolution.h"

	#include <cstdint>

	#include <log/log.h>

	#include "androidfw/AssetManager2.h"
	#include "androidfw/AttributeFinder.h"

	constexpr bool kDebugStyles = false;
	#define DEBUG_LOG(...) do { if (kDebugStyles) { ALOGI(__VA_ARGS__); } } while(0)

	namespace android {

	namespace {

	// Java asset cookies have 0 as an invalid cookie, but TypedArray expects < 0.
	static uint32_t ApkAssetsCookieToJavaCookie(ApkAssetsCookie cookie) {
	return cookie != kInvalidCookie ? static_cast<uint32_t>(cookie + 1) : static_cast<uint32_t>(-1);
	}

	class XmlAttributeFinder
	: public BackTrackingAttributeFinder<XmlAttributeFinder, size_t> {
	public:
	explicit XmlAttributeFinder(const ResXMLParser* parser)
	: BackTrackingAttributeFinder(0, parser != nullptr ? parser->getAttributeCount() : 0),
	parser_(parser) {}

	inline uint32_t GetAttribute(size_t index) const {
	return parser_->getAttributeNameResID(index);
	}

	private:
	const ResXMLParser* parser_;
	};

	class BagAttributeFinder
	: public BackTrackingAttributeFinder<BagAttributeFinder, const ResolvedBag::Entry*> {
	public:
	explicit BagAttributeFinder(const ResolvedBag* bag)
	: BackTrackingAttributeFinder(bag != nullptr ? bag->entries : nullptr,
	bag != nullptr ? bag->entries + bag->entry_count : nullptr) {
	}

	inline uint32_t GetAttribute(const ResolvedBag::Entry* entry) const {
	return entry->key;
	}
	};

	base::expected<const ResolvedBag, NullOrIOError> GetStyleBag(Theme theme,
	uint32_t theme_attribute_resid,
	uint32_t fallback_resid,
	uint32_t* out_theme_flags) {
	// Load the style from the attribute if specified.
	if (theme_attribute_resid != 0U) {
	std::optional<AssetManager2::SelectedValue> value = theme->GetAttribute(theme_attribute_resid);
	if (value.has_value()) {
	*out_theme_flags \|= value->flags;
	auto result = theme->GetAssetManager()->ResolveBag(*value);
	if (result.has_value() \|\| IsIOError(result)) {
	return result;
	}
	}
	}

	// Fallback to loading the style from the resource id if specified.
	if (fallback_resid != 0U) {
	return theme->GetAssetManager()->GetBag(fallback_resid);
	}

	return base::unexpected(std::nullopt);
	}

	base::expected<const ResolvedBag, NullOrIOError> GetXmlStyleBag(Theme theme,
	ResXMLParser* xml_parser,
	uint32_t* out_theme_flags) {
	if (xml_parser == nullptr) {
	return base::unexpected(std::nullopt);
	}

	// Retrieve the style resource ID associated with the current XML tag's style attribute.
	Res_value value;
	const ssize_t idx = xml_parser->indexOfStyle();
	if (idx < 0 \|\| xml_parser->getAttributeValue(idx, &value) < 0) {
	return base::unexpected(std::nullopt);
	}

	if (value.dataType == Res_value::TYPE_ATTRIBUTE) {
	// Resolve the attribute with out theme.
	if (std::optional<AssetManager2::SelectedValue> result = theme->GetAttribute(value.data)) {
	*out_theme_flags \|= result->flags;
	return theme->GetAssetManager()->ResolveBag(*result);
	}
	}

	if (value.dataType == Res_value::TYPE_REFERENCE) {
	return theme->GetAssetManager()->GetBag(value.data);
	}

	return base::unexpected(std::nullopt);
	}

	} // namespace

	base::expected<std::monostate, IOError> ResolveAttrs(Theme* theme, uint32_t def_style_attr,
	uint32_t def_style_res, uint32_t* src_values,
	size_t src_values_length, uint32_t* attrs,
	size_t attrs_length, uint32_t* out_values,
	uint32_t* out_indices) {
	DEBUG_LOG("APPLY STYLE: theme=0x%p defStyleAttr=0x%x defStyleRes=0x%x", theme, def_style_attr,
	def_style_res);

	int indices_idx = 0;
	const AssetManager2* assetmanager = theme->GetAssetManager();

	// Load default style from attribute or resource id, if specified...
	uint32_t def_style_theme_flags = 0U;
	const auto default_style_bag = GetStyleBag(theme, def_style_attr, def_style_res,
	&def_style_theme_flags);
	if (UNLIKELY(IsIOError(default_style_bag))) {
	return base::unexpected(GetIOError(default_style_bag.error()));
	}

	BagAttributeFinder def_style_attr_finder(default_style_bag.value_or(nullptr));

	// Now iterate through all of the attributes that the client has requested,
	// filling in each with whatever data we can find.
	for (size_t ii = 0; ii < attrs_length; ii++) {
	const uint32_t cur_ident = attrs[ii];
	DEBUG_LOG("RETRIEVING ATTR 0x%08x...", cur_ident);

	// Try to find a value for this attribute... we prioritize values
	// coming from, first XML attributes, then XML style, then default
	// style, and finally the theme.

	// Retrieve the current input value if available.
	AssetManager2::SelectedValue value{};
	if (src_values_length > 0 && src_values[ii] != 0) {
	value.type = Res_value::TYPE_ATTRIBUTE;
	value.data = src_values[ii];
	DEBUG_LOG("-> From values: type=0x%x, data=0x%08x", value.type, value.data);
	} else {
	const ResolvedBag::Entry* const entry = def_style_attr_finder.Find(cur_ident);
	if (entry != def_style_attr_finder.end()) {
	value = AssetManager2::SelectedValue(default_style_bag, entry);
	value.flags \|= def_style_theme_flags;
	DEBUG_LOG("-> From def style: type=0x%x, data=0x%08x", value.type, value.data);
	}
	}

	if (value.type != Res_value::TYPE_NULL) {
	// Take care of resolving the found resource to its final value.
	const auto result = theme->ResolveAttributeReference(value);
	if (UNLIKELY(IsIOError(result))) {
	return base::unexpected(GetIOError(result.error()));
	}
	DEBUG_LOG("-> Resolved attr: type=0x%x, data=0x%08x", value.type, value.data);
	} else if (value.data != Res_value::DATA_NULL_EMPTY) {
	// If we still don't have a value for this attribute, try to find it in the theme!
	if (auto attr_value = theme->GetAttribute(cur_ident)) {
	value = *attr_value;
	DEBUG_LOG("-> From theme: type=0x%x, data=0x%08x", value.type, value.data);

	const auto result = assetmanager->ResolveReference(value, true /* cache_value */);
	if (UNLIKELY(IsIOError(result))) {
	return base::unexpected(GetIOError(result.error()));
	}
	DEBUG_LOG("-> Resolved theme: type=0x%x, data=0x%08x", value.type, value.data);
	}
	}

	// Deal with the special @null value -- it turns back to TYPE_NULL.
	if (value.type == Res_value::TYPE_REFERENCE && value.data == 0) {
	DEBUG_LOG("-> Setting to @null!");
	value.type = Res_value::TYPE_NULL;
	value.data = Res_value::DATA_NULL_UNDEFINED;
	value.cookie = kInvalidCookie;
	}

	DEBUG_LOG("Attribute 0x%08x: type=0x%x, data=0x%08x", cur_ident, value.type, value.data);

	// Write the final value back to Java.
	out_values[STYLE_TYPE] = value.type;
	out_values[STYLE_DATA] = value.data;
	out_values[STYLE_ASSET_COOKIE] = ApkAssetsCookieToJavaCookie(value.cookie);
	out_values[STYLE_RESOURCE_ID] = value.resid;
	out_values[STYLE_CHANGING_CONFIGURATIONS] = value.flags;
	out_values[STYLE_DENSITY] = value.config.density;

	if (out_indices != nullptr &&
	(value.type != Res_value::TYPE_NULL \|\| value.data == Res_value::DATA_NULL_EMPTY)) {
	out_indices[++indices_idx] = ii;
	}

	out_values += STYLE_NUM_ENTRIES;
	}

	if (out_indices != nullptr) {
	out_indices[0] = indices_idx;
	}
	return {};
	}

	base::expected<std::monostate, IOError> ApplyStyle(Theme* theme, ResXMLParser* xml_parser,
	uint32_t def_style_attr,
	uint32_t def_style_resid,
	const uint32_t* attrs, size_t attrs_length,
	uint32_t* out_values, uint32_t* out_indices) {
	DEBUG_LOG("APPLY STYLE: theme=0x%p defStyleAttr=0x%x defStyleRes=0x%x xml=0x%p", theme,
	def_style_attr, def_style_resid, xml_parser);

	int indices_idx = 0;
	const AssetManager2* assetmanager = theme->GetAssetManager();

	// Load default style from attribute, if specified...
	uint32_t def_style_theme_flags = 0U;
	const auto default_style_bag = GetStyleBag(theme, def_style_attr, def_style_resid,
	&def_style_theme_flags);
	if (IsIOError(default_style_bag)) {
	return base::unexpected(GetIOError(default_style_bag.error()));
	}

	// Retrieve the style resource ID associated with the current XML tag's style attribute.
	uint32_t xml_style_theme_flags = 0U;
	const auto xml_style_bag = GetXmlStyleBag(theme, xml_parser, &def_style_theme_flags);
	if (IsIOError(xml_style_bag)) {
	return base::unexpected(GetIOError(xml_style_bag.error()));
	}

	BagAttributeFinder def_style_attr_finder(default_style_bag.value_or(nullptr));
	BagAttributeFinder xml_style_attr_finder(xml_style_bag.value_or(nullptr));
	XmlAttributeFinder xml_attr_finder(xml_parser);

	// Now iterate through all of the attributes that the client has requested,
	// filling in each with whatever data we can find.
	for (size_t ii = 0; ii < attrs_length; ii++) {
	const uint32_t cur_ident = attrs[ii];
	DEBUG_LOG("RETRIEVING ATTR 0x%08x...", cur_ident);

	AssetManager2::SelectedValue value{};
	uint32_t value_source_resid = 0;

	// Try to find a value for this attribute... we prioritize values
	// coming from, first XML attributes, then XML style, then default
	// style, and finally the theme.

	// Walk through the xml attributes looking for the requested attribute.
	const size_t xml_attr_idx = xml_attr_finder.Find(cur_ident);
	if (xml_attr_idx != xml_attr_finder.end()) {
	// We found the attribute we were looking for.
	Res_value attribute_value{};
	xml_parser->getAttributeValue(xml_attr_idx, &attribute_value);
	value.type = attribute_value.dataType;
	value.data = attribute_value.data;
	value_source_resid = xml_parser->getSourceResourceId();
	DEBUG_LOG("-> From XML: type=0x%x, data=0x%08x", value.type, value.data);
	}

	if (value.type == Res_value::TYPE_NULL && value.data != Res_value::DATA_NULL_EMPTY) {
	// Walk through the style class values looking for the requested attribute.
	const ResolvedBag::Entry* entry = xml_style_attr_finder.Find(cur_ident);
	if (entry != xml_style_attr_finder.end()) {
	value = AssetManager2::SelectedValue(xml_style_bag, entry);
	value.flags \|= xml_style_theme_flags;
	value_source_resid = entry->style;
	DEBUG_LOG("-> From style: type=0x%x, data=0x%08x, style=0x%08x", value.type, value.data,
	value_source_resid);
	}
	}

	if (value.type == Res_value::TYPE_NULL && value.data != Res_value::DATA_NULL_EMPTY) {
	// Walk through the default style values looking for the requested attribute.
	const ResolvedBag::Entry* entry = def_style_attr_finder.Find(cur_ident);
	if (entry != def_style_attr_finder.end()) {
	value = AssetManager2::SelectedValue(default_style_bag, entry);
	value.flags \|= def_style_theme_flags;
	value_source_resid = entry->style;
	DEBUG_LOG("-> From def style: type=0x%x, data=0x%08x, style=0x%08x", value.type, value.data,
	entry->style);
	}
	}

	if (value.type != Res_value::TYPE_NULL) {
	// Take care of resolving the found resource to its final value.
	auto result = theme->ResolveAttributeReference(value);
	if (UNLIKELY(IsIOError(result))) {
	return base::unexpected(GetIOError(result.error()));
	}
	DEBUG_LOG("-> Resolved attr: type=0x%x, data=0x%08x", value.type, value.data);
	} else if (value.data != Res_value::DATA_NULL_EMPTY) {
	// If we still don't have a value for this attribute, try to find it in the theme!
	if (auto attr_value = theme->GetAttribute(cur_ident)) {
	value = *attr_value;
	DEBUG_LOG("-> From theme: type=0x%x, data=0x%08x", value.type, value.data);

	auto result = assetmanager->ResolveReference(value, true /* cache_value */);
	if (UNLIKELY(IsIOError(result))) {
	return base::unexpected(GetIOError(result.error()));
	}
	DEBUG_LOG("-> Resolved theme: type=0x%x, data=0x%08x", value.type, value.data);
	// TODO: set value_source_resid for the style in the theme that was used.
	}
	}

	// Deal with the special @null value -- it turns back to TYPE_NULL.
	if (value.type == Res_value::TYPE_REFERENCE && value.data == 0U) {
	DEBUG_LOG("-> Setting to @null!");
	value.type = Res_value::TYPE_NULL;
	value.data = Res_value::DATA_NULL_UNDEFINED;
	value.cookie = kInvalidCookie;
	}

	DEBUG_LOG("Attribute 0x%08x: type=0x%x, data=0x%08x", cur_ident, value.type, value.data);

	// Write the final value back to Java.
	out_values[STYLE_TYPE] = value.type;
	out_values[STYLE_DATA] = value.data;
	out_values[STYLE_ASSET_COOKIE] = ApkAssetsCookieToJavaCookie(value.cookie);
	out_values[STYLE_RESOURCE_ID] = value.resid;
	out_values[STYLE_CHANGING_CONFIGURATIONS] = value.flags;
	out_values[STYLE_DENSITY] = value.config.density;
	out_values[STYLE_SOURCE_RESOURCE_ID] = value_source_resid;

	if (value.type != Res_value::TYPE_NULL \|\| value.data == Res_value::DATA_NULL_EMPTY) {
	// out_indices must NOT be nullptr.
	out_indices[++indices_idx] = ii;
	}
	out_values += STYLE_NUM_ENTRIES;
	}

	// out_indices must NOT be nullptr.
	out_indices[0] = indices_idx;
	return {};
	}

	base::expected<std::monostate, IOError> RetrieveAttributes(AssetManager2* assetmanager,
	ResXMLParser* xml_parser,
	uint32_t* attrs,
	size_t attrs_length,
	uint32_t* out_values,
	uint32_t* out_indices) {
	int indices_idx = 0;

	// Retrieve the XML attributes, if requested.
	size_t ix = 0;
	const size_t xml_attr_count = xml_parser->getAttributeCount();
	uint32_t cur_xml_attr = xml_parser->getAttributeNameResID(ix);

	// Now iterate through all of the attributes that the client has requested,
	// filling in each with whatever data we can find.
	for (size_t ii = 0; ii < attrs_length; ii++) {
	const uint32_t cur_ident = attrs[ii];
	AssetManager2::SelectedValue value{};

	// Try to find a value for this attribute...
	// Skip through XML attributes until the end or the next possible match.
	while (ix < xml_attr_count && cur_ident > cur_xml_attr) {
	cur_xml_attr = xml_parser->getAttributeNameResID(++ix);
	}

	// Retrieve the current XML attribute if it matches, and step to next.
	if (ix < xml_attr_count && cur_ident == cur_xml_attr) {
	Res_value attribute_value{};
	xml_parser->getAttributeValue(ix, &attribute_value);
	value.type = attribute_value.dataType;
	value.data = attribute_value.data;
	cur_xml_attr = xml_parser->getAttributeNameResID(++ix);
	}

	if (value.type != Res_value::TYPE_NULL) {
	// Take care of resolving the found resource to its final value.
	auto result = assetmanager->ResolveReference(value);
	if (UNLIKELY(IsIOError(result))) {
	return base::unexpected(GetIOError(result.error()));
	}
	}

	// Deal with the special @null value -- it turns back to TYPE_NULL.
	if (value.type == Res_value::TYPE_REFERENCE && value.data == 0U) {
	value.type = Res_value::TYPE_NULL;
	value.data = Res_value::DATA_NULL_UNDEFINED;
	value.cookie = kInvalidCookie;
	}

	// Write the final value back to Java.
	out_values[STYLE_TYPE] = value.type;
	out_values[STYLE_DATA] = value.data;
	out_values[STYLE_ASSET_COOKIE] = ApkAssetsCookieToJavaCookie(value.cookie);
	out_values[STYLE_RESOURCE_ID] = value.resid;
	out_values[STYLE_CHANGING_CONFIGURATIONS] = value.flags;
	out_values[STYLE_DENSITY] = value.config.density;

	if (out_indices != nullptr &&
	(value.type != Res_value::TYPE_NULL \|\|
	value.data == Res_value::DATA_NULL_EMPTY)) {
	out_indices[++indices_idx] = ii;
	}

	out_values += STYLE_NUM_ENTRIES;
	}

	if (out_indices != nullptr) {
	out_indices[0] = indices_idx;
	}
	return {};
	}

	} // namespace android