blob: 2e17659b06790695b475aefda764d59b38a96674 [file] [log] [blame]
/*
* Copyright (C) 2015 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.
*/
#ifndef AAPT_RESOURCE_TABLE_H
#define AAPT_RESOURCE_TABLE_H
#include "Diagnostics.h"
#include "Resource.h"
#include "ResourceValues.h"
#include "Source.h"
#include "StringPool.h"
#include "io/File.h"
#include "android-base/macros.h"
#include "androidfw/ConfigDescription.h"
#include "androidfw/StringPiece.h"
#include <functional>
#include <map>
#include <memory>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
using PolicyFlags = android::ResTable_overlayable_policy_header::PolicyFlags;
namespace aapt {
// The Public status of a resource.
struct Visibility {
enum class Level {
kUndefined,
kPrivate,
kPublic,
};
Level level = Level::kUndefined;
Source source;
std::string comment;
// Indicates that the resource id may change across builds and that the public R.java identifier
// for this resource should not be final. This is set to `true` for resources in `staging-group`
// tags.
bool staged_api = false;
};
// Represents <add-resource> in an overlay.
struct AllowNew {
Source source;
std::string comment;
};
// Represents the staged resource id of a finalized resource.
struct StagedId {
ResourceId id;
Source source;
};
struct Overlayable {
Overlayable() = default;
Overlayable(const android::StringPiece& name, const android::StringPiece& actor)
: name(name.to_string()), actor(actor.to_string()) {}
Overlayable(const android::StringPiece& name, const android::StringPiece& actor,
const Source& source)
: name(name.to_string()), actor(actor.to_string()), source(source ){}
static const char* kActorScheme;
std::string name;
std::string actor;
Source source;
};
// Represents a declaration that a resource is overlayable at runtime.
struct OverlayableItem {
explicit OverlayableItem(const std::shared_ptr<Overlayable>& overlayable)
: overlayable(overlayable) {}
std::shared_ptr<Overlayable> overlayable;
PolicyFlags policies = PolicyFlags::NONE;
std::string comment;
Source source;
};
class ResourceConfigValue {
public:
// The configuration for which this value is defined.
const android::ConfigDescription config;
// The product for which this value is defined.
const std::string product;
// The actual Value.
std::unique_ptr<Value> value;
ResourceConfigValue(const android::ConfigDescription& config, const android::StringPiece& product)
: config(config), product(product.to_string()) {}
private:
DISALLOW_COPY_AND_ASSIGN(ResourceConfigValue);
};
// Represents a resource entry, which may have varying values for each defined configuration.
class ResourceEntry {
public:
// The name of the resource. Immutable, as this determines the order of this resource
// when doing lookups.
const std::string name;
// The entry ID for this resource (the EEEE in 0xPPTTEEEE).
std::optional<ResourceId> id;
// Whether this resource is public (and must maintain the same entry ID across builds).
Visibility visibility;
std::optional<AllowNew> allow_new;
// The declarations of this resource as overlayable for RROs
std::optional<OverlayableItem> overlayable_item;
// The staged resource id for a finalized resource.
std::optional<StagedId> staged_id;
// The resource's values for each configuration.
std::vector<std::unique_ptr<ResourceConfigValue>> values;
explicit ResourceEntry(const android::StringPiece& name) : name(name.to_string()) {}
ResourceConfigValue* FindValue(const android::ConfigDescription& config,
android::StringPiece product = {});
const ResourceConfigValue* FindValue(const android::ConfigDescription& config,
android::StringPiece product = {}) const;
ResourceConfigValue* FindOrCreateValue(const android::ConfigDescription& config,
const android::StringPiece& product);
std::vector<ResourceConfigValue*> FindAllValues(const android::ConfigDescription& config);
template <typename Func>
std::vector<ResourceConfigValue*> FindValuesIf(Func f) {
std::vector<ResourceConfigValue*> results;
for (auto& config_value : values) {
if (f(config_value.get())) {
results.push_back(config_value.get());
}
}
return results;
}
bool HasDefaultValue() const;
private:
DISALLOW_COPY_AND_ASSIGN(ResourceEntry);
};
// Represents a resource type (eg. string, drawable, layout, etc.) containing resource entries.
class ResourceTableType {
public:
// The logical type of resource (string, drawable, layout, etc.).
const ResourceType type;
// Whether this type is public (and must maintain the same type ID across builds).
Visibility::Level visibility_level = Visibility::Level::kUndefined;
// List of resources for this type.
std::vector<std::unique_ptr<ResourceEntry>> entries;
explicit ResourceTableType(const ResourceType type) : type(type) {}
ResourceEntry* CreateEntry(const android::StringPiece& name);
ResourceEntry* FindEntry(const android::StringPiece& name) const;
ResourceEntry* FindOrCreateEntry(const android::StringPiece& name);
private:
DISALLOW_COPY_AND_ASSIGN(ResourceTableType);
};
class ResourceTablePackage {
public:
std::string name;
std::vector<std::unique_ptr<ResourceTableType>> types;
explicit ResourceTablePackage(const android::StringPiece& name) : name(name.to_string()) {
}
ResourceTablePackage() = default;
ResourceTableType* FindType(ResourceType type) const;
ResourceTableType* FindOrCreateType(ResourceType type);
private:
DISALLOW_COPY_AND_ASSIGN(ResourceTablePackage);
};
struct ResourceTableEntryView {
std::string name;
std::optional<uint16_t> id;
Visibility visibility;
std::optional<AllowNew> allow_new;
std::optional<OverlayableItem> overlayable_item;
std::optional<StagedId> staged_id;
std::vector<const ResourceConfigValue*> values;
const ResourceConfigValue* FindValue(const android::ConfigDescription& config,
android::StringPiece product = {}) const;
};
struct ResourceTableTypeView {
ResourceType type;
std::optional<uint8_t> id;
Visibility::Level visibility_level = Visibility::Level::kUndefined;
// Entries sorted in ascending entry id order. If ids have not been assigned, the entries are
// sorted lexicographically.
std::vector<ResourceTableEntryView> entries;
};
struct ResourceTablePackageView {
std::string name;
std::optional<uint8_t> id;
// Types sorted in ascending type id order. If ids have not been assigned, the types are sorted by
// their declaration order in the ResourceType enum.
std::vector<ResourceTableTypeView> types;
};
struct ResourceTableViewOptions {
bool create_alias_entries = false;
};
struct ResourceTableView {
// Packages sorted in ascending package id order. If ids have not been assigned, the packages are
// sorted lexicographically.
std::vector<ResourceTablePackageView> packages;
};
enum class OnIdConflict {
// If the resource entry already exists but has a different resource id, the resource value will
// not be added to the table.
ERROR,
// If the resource entry already exists but has a different resource id, create a new resource
// with this resource name and id combination.
CREATE_ENTRY,
};
struct NewResource {
ResourceName name;
std::unique_ptr<Value> value;
android::ConfigDescription config;
std::string product;
std::optional<std::pair<ResourceId, OnIdConflict>> id;
std::optional<Visibility> visibility;
std::optional<OverlayableItem> overlayable;
std::optional<AllowNew> allow_new;
std::optional<StagedId> staged_id;
bool allow_mangled = false;
};
struct NewResourceBuilder {
explicit NewResourceBuilder(const ResourceNameRef& name);
explicit NewResourceBuilder(const std::string& name);
NewResourceBuilder& SetValue(std::unique_ptr<Value> value, android::ConfigDescription config = {},
std::string product = {});
NewResourceBuilder& SetId(ResourceId id, OnIdConflict on_conflict = OnIdConflict::ERROR);
NewResourceBuilder& SetVisibility(Visibility id);
NewResourceBuilder& SetOverlayable(OverlayableItem overlayable);
NewResourceBuilder& SetAllowNew(AllowNew allow_new);
NewResourceBuilder& SetStagedId(StagedId id);
NewResourceBuilder& SetAllowMangled(bool allow_mangled);
NewResource Build();
private:
NewResource res_;
};
// The container and index for all resources defined for an app.
class ResourceTable {
public:
enum class Validation {
kEnabled,
kDisabled,
};
enum class CollisionResult { kKeepBoth, kKeepOriginal, kConflict, kTakeNew };
ResourceTable() = default;
explicit ResourceTable(Validation validation);
bool AddResource(NewResource&& res, IDiagnostics* diag);
// Retrieves a sorted a view of the packages, types, and entries sorted in ascending resource id
// order.
ResourceTableView GetPartitionedView(const ResourceTableViewOptions& options = {}) const;
struct SearchResult {
ResourceTablePackage* package;
ResourceTableType* type;
ResourceEntry* entry;
};
std::optional<SearchResult> FindResource(const ResourceNameRef& name) const;
std::optional<SearchResult> FindResource(const ResourceNameRef& name, ResourceId id) const;
bool RemoveResource(const ResourceNameRef& name, ResourceId id) const;
// Returns the package struct with the given name, or nullptr if such a package does not
// exist. The empty string is a valid package and typically is used to represent the
// 'current' package before it is known to the ResourceTable.
ResourceTablePackage* FindPackage(const android::StringPiece& name) const;
ResourceTablePackage* FindOrCreatePackage(const android::StringPiece& name);
std::unique_ptr<ResourceTable> Clone() const;
// When a collision of resources occurs, this method decides which value to keep.
static CollisionResult ResolveValueCollision(Value* existing, Value* incoming);
// The string pool used by this resource table. Values that reference strings must use
// this pool to create their strings.
// NOTE: `string_pool` must come before `packages` so that it is destroyed after.
// When `string_pool` references are destroyed (as they will be when `packages` is destroyed),
// they decrement a refCount, which would cause invalid memory access if the pool was already
// destroyed.
StringPool string_pool;
// The list of packages in this table, sorted alphabetically by package name and increasing
// package ID (missing ID being the lowest).
std::vector<std::unique_ptr<ResourceTablePackage>> packages;
// Set of dynamic packages that this table may reference. Their package names get encoded
// into the resources.arsc along with their compile-time assigned IDs.
std::map<size_t, std::string> included_packages_;
private:
DISALLOW_COPY_AND_ASSIGN(ResourceTable);
Validation validation_ = Validation::kEnabled;
};
} // namespace aapt
#endif // AAPT_RESOURCE_TABLE_H