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 #include "xml/XmlUtil.h"
18
19 #include <algorithm>
20 #include <string>
21
22 #include "util/Util.h"
23 #include "xml/XmlDom.h"
24
25 using ::android::StringPiece;
26
27 namespace aapt {
28 namespace xml {
29
BuildPackageNamespace(const StringPiece & package,bool private_reference)30 std::string BuildPackageNamespace(const StringPiece& package, bool private_reference) {
31 std::string result = private_reference ? kSchemaPrivatePrefix : kSchemaPublicPrefix;
32 result.append(package.data(), package.size());
33 return result;
34 }
35
ExtractPackageFromNamespace(const std::string & namespace_uri)36 std::optional<ExtractedPackage> ExtractPackageFromNamespace(const std::string& namespace_uri) {
37 if (util::StartsWith(namespace_uri, kSchemaPublicPrefix)) {
38 StringPiece schema_prefix = kSchemaPublicPrefix;
39 StringPiece package = namespace_uri;
40 package = package.substr(schema_prefix.size(), package.size() - schema_prefix.size());
41 if (package.empty()) {
42 return {};
43 }
44 return ExtractedPackage{package.to_string(), false /* is_private */};
45
46 } else if (util::StartsWith(namespace_uri, kSchemaPrivatePrefix)) {
47 StringPiece schema_prefix = kSchemaPrivatePrefix;
48 StringPiece package = namespace_uri;
49 package = package.substr(schema_prefix.size(), package.size() - schema_prefix.size());
50 if (package.empty()) {
51 return {};
52 }
53 return ExtractedPackage{package.to_string(), true /* is_private */};
54
55 } else if (namespace_uri == kSchemaAuto) {
56 return ExtractedPackage{std::string(), true /* is_private */};
57 }
58 return {};
59 }
60
ResolvePackage(const IPackageDeclStack * decl_stack,Reference * in_ref)61 void ResolvePackage(const IPackageDeclStack* decl_stack, Reference* in_ref) {
62 if (in_ref->name) {
63 if (std::optional<ExtractedPackage> transformed_package =
64 decl_stack->TransformPackageAlias(in_ref->name.value().package)) {
65 ExtractedPackage& extracted_package = transformed_package.value();
66 in_ref->name.value().package = std::move(extracted_package.package);
67
68 // If the reference was already private (with a * prefix) and the
69 // namespace is public, we keep the reference private.
70 in_ref->private_reference |= extracted_package.private_namespace;
71 }
72 }
73 }
74
75 namespace {
76
77 class ToolsNamespaceRemover : public Visitor {
78 public:
79 using Visitor::Visit;
80
Visit(Element * el)81 void Visit(Element* el) override {
82 auto new_end =
83 std::remove_if(el->namespace_decls.begin(), el->namespace_decls.end(),
84 [](const NamespaceDecl& decl) -> bool { return decl.uri == kSchemaTools; });
85 el->namespace_decls.erase(new_end, el->namespace_decls.end());
86
87 auto new_attr_end = std::remove_if(
88 el->attributes.begin(), el->attributes.end(),
89 [](const Attribute& attr) -> bool { return attr.namespace_uri == kSchemaTools; });
90 el->attributes.erase(new_attr_end, el->attributes.end());
91
92 Visitor::Visit(el);
93 }
94 };
95
96 } // namespace
97
StripAndroidStudioAttributes(Element * el)98 void StripAndroidStudioAttributes(Element* el) {
99 ToolsNamespaceRemover remover;
100 el->Accept(&remover);
101 }
102
103 } // namespace xml
104 } // namespace aapt
105