Adam Lesinski | 2ae4a87 | 2015-11-02 16:10:55 -0800 | [diff] [blame] | 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 | |
Adam Lesinski | 2ae4a87 | 2015-11-02 16:10:55 -0800 | [diff] [blame] | 17 | #include "link/ManifestFixer.h" |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 18 | |
| 19 | #include <unordered_set> |
| 20 | |
| 21 | #include "android-base/logging.h" |
| 22 | |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 23 | #include "ResourceUtils.h" |
Fabien Sanglard | 2d34e76 | 2019-02-21 15:13:29 -0800 | [diff] [blame] | 24 | #include "trace/TraceBuffer.h" |
Adam Lesinski | 2ae4a87 | 2015-11-02 16:10:55 -0800 | [diff] [blame] | 25 | #include "util/Util.h" |
Adam Lesinski | cc5609d | 2016-04-05 12:41:07 -0700 | [diff] [blame] | 26 | #include "xml/XmlActionExecutor.h" |
Adam Lesinski | 467f171 | 2015-11-16 17:35:44 -0800 | [diff] [blame] | 27 | #include "xml/XmlDom.h" |
Adam Lesinski | 2ae4a87 | 2015-11-02 16:10:55 -0800 | [diff] [blame] | 28 | |
Adam Lesinski | d5083f6 | 2017-01-16 15:07:21 -0800 | [diff] [blame] | 29 | using android::StringPiece; |
| 30 | |
Adam Lesinski | 2ae4a87 | 2015-11-02 16:10:55 -0800 | [diff] [blame] | 31 | namespace aapt { |
| 32 | |
Adam Lesinski | fca5e42 | 2017-12-20 15:03:36 -0800 | [diff] [blame] | 33 | static bool RequiredNameIsNotEmpty(xml::Element* el, SourcePathDiagnostics* diag) { |
| 34 | xml::Attribute* attr = el->FindAttribute(xml::kSchemaAndroid, "name"); |
| 35 | if (attr == nullptr) { |
| 36 | diag->Error(DiagMessage(el->line_number) |
| 37 | << "<" << el->name << "> is missing attribute 'android:name'"); |
| 38 | return false; |
| 39 | } |
| 40 | |
| 41 | if (attr->value.empty()) { |
| 42 | diag->Error(DiagMessage(el->line_number) |
| 43 | << "attribute 'android:name' in <" << el->name << "> tag must not be empty"); |
| 44 | return false; |
| 45 | } |
| 46 | return true; |
| 47 | } |
| 48 | |
Adam Lesinski | b0c47ef | 2017-03-06 20:05:57 -0800 | [diff] [blame] | 49 | // This is how PackageManager builds class names from AndroidManifest.xml entries. |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 50 | static bool NameIsJavaClassName(xml::Element* el, xml::Attribute* attr, |
Adam Lesinski | cc5609d | 2016-04-05 12:41:07 -0700 | [diff] [blame] | 51 | SourcePathDiagnostics* diag) { |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 52 | // We allow unqualified class names (ie: .HelloActivity) |
| 53 | // Since we don't know the package name, we can just make a fake one here and |
| 54 | // the test will be identical as long as the real package name is valid too. |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 55 | Maybe<std::string> fully_qualified_class_name = |
| 56 | util::GetFullyQualifiedClassName("a", attr->value); |
Adam Lesinski | cc5609d | 2016-04-05 12:41:07 -0700 | [diff] [blame] | 57 | |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 58 | StringPiece qualified_class_name = fully_qualified_class_name |
| 59 | ? fully_qualified_class_name.value() |
| 60 | : attr->value; |
Adam Lesinski | d0f116b | 2016-07-08 15:00:32 -0700 | [diff] [blame] | 61 | |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 62 | if (!util::IsJavaClassName(qualified_class_name)) { |
| 63 | diag->Error(DiagMessage(el->line_number) |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 64 | << "attribute 'android:name' in <" << el->name |
| 65 | << "> tag must be a valid Java class name"); |
Adam Lesinski | 52364f7 | 2016-01-11 13:10:24 -0800 | [diff] [blame] | 66 | return false; |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 67 | } |
| 68 | return true; |
| 69 | } |
| 70 | |
Adam Lesinski | ceb9b2f | 2017-02-16 12:05:42 -0800 | [diff] [blame] | 71 | static bool OptionalNameIsJavaClassName(xml::Element* el, SourcePathDiagnostics* diag) { |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 72 | if (xml::Attribute* attr = el->FindAttribute(xml::kSchemaAndroid, "name")) { |
| 73 | return NameIsJavaClassName(el, attr, diag); |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 74 | } |
| 75 | return true; |
| 76 | } |
| 77 | |
Adam Lesinski | ceb9b2f | 2017-02-16 12:05:42 -0800 | [diff] [blame] | 78 | static bool RequiredNameIsJavaClassName(xml::Element* el, SourcePathDiagnostics* diag) { |
Adam Lesinski | fca5e42 | 2017-12-20 15:03:36 -0800 | [diff] [blame] | 79 | xml::Attribute* attr = el->FindAttribute(xml::kSchemaAndroid, "name"); |
| 80 | if (attr == nullptr) { |
| 81 | diag->Error(DiagMessage(el->line_number) |
| 82 | << "<" << el->name << "> is missing attribute 'android:name'"); |
| 83 | return false; |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 84 | } |
Adam Lesinski | fca5e42 | 2017-12-20 15:03:36 -0800 | [diff] [blame] | 85 | return NameIsJavaClassName(el, attr, diag); |
Adam Lesinski | 52364f7 | 2016-01-11 13:10:24 -0800 | [diff] [blame] | 86 | } |
| 87 | |
Adam Lesinski | ceb9b2f | 2017-02-16 12:05:42 -0800 | [diff] [blame] | 88 | static bool RequiredNameIsJavaPackage(xml::Element* el, SourcePathDiagnostics* diag) { |
Adam Lesinski | fca5e42 | 2017-12-20 15:03:36 -0800 | [diff] [blame] | 89 | xml::Attribute* attr = el->FindAttribute(xml::kSchemaAndroid, "name"); |
| 90 | if (attr == nullptr) { |
| 91 | diag->Error(DiagMessage(el->line_number) |
| 92 | << "<" << el->name << "> is missing attribute 'android:name'"); |
| 93 | return false; |
Adam Lesinski | ceb9b2f | 2017-02-16 12:05:42 -0800 | [diff] [blame] | 94 | } |
Adam Lesinski | fca5e42 | 2017-12-20 15:03:36 -0800 | [diff] [blame] | 95 | |
| 96 | if (!util::IsJavaPackageName(attr->value)) { |
| 97 | diag->Error(DiagMessage(el->line_number) << "attribute 'android:name' in <" << el->name |
| 98 | << "> tag must be a valid Java package name"); |
| 99 | return false; |
| 100 | } |
| 101 | return true; |
Adam Lesinski | ceb9b2f | 2017-02-16 12:05:42 -0800 | [diff] [blame] | 102 | } |
| 103 | |
Adam Lesinski | b5dc4bd | 2017-02-22 19:29:29 -0800 | [diff] [blame] | 104 | static xml::XmlNodeAction::ActionFuncWithDiag RequiredAndroidAttribute(const std::string& attr) { |
| 105 | return [=](xml::Element* el, SourcePathDiagnostics* diag) -> bool { |
| 106 | if (el->FindAttribute(xml::kSchemaAndroid, attr) == nullptr) { |
| 107 | diag->Error(DiagMessage(el->line_number) |
| 108 | << "<" << el->name << "> is missing required attribute 'android:" << attr << "'"); |
| 109 | return false; |
| 110 | } |
| 111 | return true; |
| 112 | }; |
| 113 | } |
| 114 | |
Adam Lesinski | b0c47ef | 2017-03-06 20:05:57 -0800 | [diff] [blame] | 115 | static bool AutoGenerateIsFeatureSplit(xml::Element* el, SourcePathDiagnostics* diag) { |
| 116 | constexpr const char* kFeatureSplit = "featureSplit"; |
| 117 | constexpr const char* kIsFeatureSplit = "isFeatureSplit"; |
| 118 | |
| 119 | xml::Attribute* attr = el->FindAttribute({}, kFeatureSplit); |
| 120 | if (attr != nullptr) { |
| 121 | // Rewrite the featureSplit attribute to be "split". This is what the |
| 122 | // platform recognizes. |
| 123 | attr->name = "split"; |
| 124 | |
| 125 | // Now inject the android:isFeatureSplit="true" attribute. |
| 126 | xml::Attribute* attr = el->FindAttribute(xml::kSchemaAndroid, kIsFeatureSplit); |
| 127 | if (attr != nullptr) { |
| 128 | if (!ResourceUtils::ParseBool(attr->value).value_or_default(false)) { |
| 129 | // The isFeatureSplit attribute is false, which conflicts with the use |
| 130 | // of "featureSplit". |
| 131 | diag->Error(DiagMessage(el->line_number) |
| 132 | << "attribute 'featureSplit' used in <manifest> but 'android:isFeatureSplit' " |
| 133 | "is not 'true'"); |
| 134 | return false; |
| 135 | } |
| 136 | |
| 137 | // The attribute is already there and set to true, nothing to do. |
| 138 | } else { |
| 139 | el->attributes.push_back(xml::Attribute{xml::kSchemaAndroid, kIsFeatureSplit, "true"}); |
| 140 | } |
| 141 | } |
| 142 | return true; |
| 143 | } |
| 144 | |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 145 | static bool VerifyManifest(xml::Element* el, SourcePathDiagnostics* diag) { |
| 146 | xml::Attribute* attr = el->FindAttribute({}, "package"); |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 147 | if (!attr) { |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 148 | diag->Error(DiagMessage(el->line_number) |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 149 | << "<manifest> tag is missing 'package' attribute"); |
| 150 | return false; |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 151 | } else if (ResourceUtils::IsReference(attr->value)) { |
Adam Lesinski | b0c47ef | 2017-03-06 20:05:57 -0800 | [diff] [blame] | 152 | diag->Error(DiagMessage(el->line_number) |
| 153 | << "attribute 'package' in <manifest> tag must not be a reference"); |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 154 | return false; |
Adam Lesinski | 96ea08f | 2017-11-06 10:44:46 -0800 | [diff] [blame] | 155 | } else if (!util::IsAndroidPackageName(attr->value)) { |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 156 | diag->Error(DiagMessage(el->line_number) |
Adam Lesinski | 96ea08f | 2017-11-06 10:44:46 -0800 | [diff] [blame] | 157 | << "attribute 'package' in <manifest> tag is not a valid Android package name: '" |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 158 | << attr->value << "'"); |
| 159 | return false; |
| 160 | } |
Adam Lesinski | b0c47ef | 2017-03-06 20:05:57 -0800 | [diff] [blame] | 161 | |
| 162 | attr = el->FindAttribute({}, "split"); |
| 163 | if (attr) { |
| 164 | if (!util::IsJavaPackageName(attr->value)) { |
| 165 | diag->Error(DiagMessage(el->line_number) << "attribute 'split' in <manifest> tag is not a " |
| 166 | "valid split name"); |
| 167 | return false; |
| 168 | } |
| 169 | } |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 170 | return true; |
Adam Lesinski | 52364f7 | 2016-01-11 13:10:24 -0800 | [diff] [blame] | 171 | } |
| 172 | |
Adam Lesinski | b0c47ef | 2017-03-06 20:05:57 -0800 | [diff] [blame] | 173 | // The coreApp attribute in <manifest> is not a regular AAPT attribute, so type |
| 174 | // checking on it is manual. |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 175 | static bool FixCoreAppAttribute(xml::Element* el, SourcePathDiagnostics* diag) { |
| 176 | if (xml::Attribute* attr = el->FindAttribute("", "coreApp")) { |
Adam Lesinski | b0c47ef | 2017-03-06 20:05:57 -0800 | [diff] [blame] | 177 | std::unique_ptr<BinaryPrimitive> result = ResourceUtils::TryParseBool(attr->value); |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 178 | if (!result) { |
Adam Lesinski | b0c47ef | 2017-03-06 20:05:57 -0800 | [diff] [blame] | 179 | diag->Error(DiagMessage(el->line_number) << "attribute coreApp must be a boolean"); |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 180 | return false; |
Adam Lesinski | 6b17d2c | 2016-08-10 11:37:06 -0700 | [diff] [blame] | 181 | } |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 182 | attr->compiled_value = std::move(result); |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 183 | } |
| 184 | return true; |
Adam Lesinski | 6b17d2c | 2016-08-10 11:37:06 -0700 | [diff] [blame] | 185 | } |
| 186 | |
Adam Lesinski | 86d67df | 2017-01-31 13:47:27 -0800 | [diff] [blame] | 187 | // Checks that <uses-feature> has android:glEsVersion or android:name, not both (or neither). |
| 188 | static bool VerifyUsesFeature(xml::Element* el, SourcePathDiagnostics* diag) { |
| 189 | bool has_name = false; |
| 190 | if (xml::Attribute* attr = el->FindAttribute(xml::kSchemaAndroid, "name")) { |
| 191 | if (attr->value.empty()) { |
| 192 | diag->Error(DiagMessage(el->line_number) |
| 193 | << "android:name in <uses-feature> must not be empty"); |
| 194 | return false; |
| 195 | } |
| 196 | has_name = true; |
| 197 | } |
| 198 | |
| 199 | bool has_gl_es_version = false; |
| 200 | if (xml::Attribute* attr = el->FindAttribute(xml::kSchemaAndroid, "glEsVersion")) { |
| 201 | if (has_name) { |
| 202 | diag->Error(DiagMessage(el->line_number) |
| 203 | << "cannot define both android:name and android:glEsVersion in <uses-feature>"); |
| 204 | return false; |
| 205 | } |
| 206 | has_gl_es_version = true; |
| 207 | } |
| 208 | |
| 209 | if (!has_name && !has_gl_es_version) { |
| 210 | diag->Error(DiagMessage(el->line_number) |
| 211 | << "<uses-feature> must have either android:name or android:glEsVersion attribute"); |
| 212 | return false; |
| 213 | } |
| 214 | return true; |
| 215 | } |
| 216 | |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 217 | bool ManifestFixer::BuildRules(xml::XmlActionExecutor* executor, |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 218 | IDiagnostics* diag) { |
| 219 | // First verify some options. |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 220 | if (options_.rename_manifest_package) { |
| 221 | if (!util::IsJavaPackageName(options_.rename_manifest_package.value())) { |
| 222 | diag->Error(DiagMessage() << "invalid manifest package override '" |
| 223 | << options_.rename_manifest_package.value() |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 224 | << "'"); |
| 225 | return false; |
| 226 | } |
| 227 | } |
| 228 | |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 229 | if (options_.rename_instrumentation_target_package) { |
Adam Lesinski | b0c47ef | 2017-03-06 20:05:57 -0800 | [diff] [blame] | 230 | if (!util::IsJavaPackageName(options_.rename_instrumentation_target_package.value())) { |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 231 | diag->Error(DiagMessage() |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 232 | << "invalid instrumentation target package override '" |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 233 | << options_.rename_instrumentation_target_package.value() |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 234 | << "'"); |
| 235 | return false; |
| 236 | } |
| 237 | } |
| 238 | |
Adam Lesinski | 86d67df | 2017-01-31 13:47:27 -0800 | [diff] [blame] | 239 | // Common <intent-filter> actions. |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 240 | xml::XmlNodeAction intent_filter_action; |
Adam Lesinski | fca5e42 | 2017-12-20 15:03:36 -0800 | [diff] [blame] | 241 | intent_filter_action["action"].Action(RequiredNameIsNotEmpty); |
| 242 | intent_filter_action["category"].Action(RequiredNameIsNotEmpty); |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 243 | intent_filter_action["data"]; |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 244 | |
Adam Lesinski | 86d67df | 2017-01-31 13:47:27 -0800 | [diff] [blame] | 245 | // Common <meta-data> actions. |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 246 | xml::XmlNodeAction meta_data_action; |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 247 | |
Adam Lesinski | 86d67df | 2017-01-31 13:47:27 -0800 | [diff] [blame] | 248 | // Common <uses-feature> actions. |
| 249 | xml::XmlNodeAction uses_feature_action; |
| 250 | uses_feature_action.Action(VerifyUsesFeature); |
| 251 | |
| 252 | // Common component actions. |
| 253 | xml::XmlNodeAction component_action; |
| 254 | component_action.Action(RequiredNameIsJavaClassName); |
| 255 | component_action["intent-filter"] = intent_filter_action; |
Ryan Mitchell | 28afe68 | 2018-09-07 14:33:14 -0700 | [diff] [blame] | 256 | component_action["preferred"] = intent_filter_action; |
Adam Lesinski | 86d67df | 2017-01-31 13:47:27 -0800 | [diff] [blame] | 257 | component_action["meta-data"] = meta_data_action; |
| 258 | |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 259 | // Manifest actions. |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 260 | xml::XmlNodeAction& manifest_action = (*executor)["manifest"]; |
Adam Lesinski | b0c47ef | 2017-03-06 20:05:57 -0800 | [diff] [blame] | 261 | manifest_action.Action(AutoGenerateIsFeatureSplit); |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 262 | manifest_action.Action(VerifyManifest); |
| 263 | manifest_action.Action(FixCoreAppAttribute); |
| 264 | manifest_action.Action([&](xml::Element* el) -> bool { |
| 265 | if (options_.version_name_default) { |
Colin Cross | dcd58c4 | 2018-05-25 22:46:35 -0700 | [diff] [blame] | 266 | if (options_.replace_version) { |
| 267 | el->RemoveAttribute(xml::kSchemaAndroid, "versionName"); |
| 268 | } |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 269 | if (el->FindAttribute(xml::kSchemaAndroid, "versionName") == nullptr) { |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 270 | el->attributes.push_back( |
| 271 | xml::Attribute{xml::kSchemaAndroid, "versionName", |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 272 | options_.version_name_default.value()}); |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 273 | } |
Adam Lesinski | cc5609d | 2016-04-05 12:41:07 -0700 | [diff] [blame] | 274 | } |
| 275 | |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 276 | if (options_.version_code_default) { |
Colin Cross | dcd58c4 | 2018-05-25 22:46:35 -0700 | [diff] [blame] | 277 | if (options_.replace_version) { |
| 278 | el->RemoveAttribute(xml::kSchemaAndroid, "versionCode"); |
| 279 | } |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 280 | if (el->FindAttribute(xml::kSchemaAndroid, "versionCode") == nullptr) { |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 281 | el->attributes.push_back( |
| 282 | xml::Attribute{xml::kSchemaAndroid, "versionCode", |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 283 | options_.version_code_default.value()}); |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 284 | } |
Adam Lesinski | cc5609d | 2016-04-05 12:41:07 -0700 | [diff] [blame] | 285 | } |
Ryan Mitchell | 7cb82a8 | 2018-05-10 15:35:31 -0700 | [diff] [blame] | 286 | |
Ryan Mitchell | 704090e | 2018-07-31 14:59:25 -0700 | [diff] [blame] | 287 | if (options_.version_code_major_default) { |
| 288 | if (options_.replace_version) { |
| 289 | el->RemoveAttribute(xml::kSchemaAndroid, "versionCodeMajor"); |
| 290 | } |
| 291 | if (el->FindAttribute(xml::kSchemaAndroid, "versionCodeMajor") == nullptr) { |
| 292 | el->attributes.push_back( |
| 293 | xml::Attribute{xml::kSchemaAndroid, "versionCodeMajor", |
| 294 | options_.version_code_major_default.value()}); |
| 295 | } |
| 296 | } |
| 297 | |
Adam Lesinski | 2ae4a87 | 2015-11-02 16:10:55 -0800 | [diff] [blame] | 298 | return true; |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 299 | }); |
| 300 | |
| 301 | // Meta tags. |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 302 | manifest_action["eat-comment"]; |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 303 | |
| 304 | // Uses-sdk actions. |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 305 | manifest_action["uses-sdk"].Action([&](xml::Element* el) -> bool { |
| 306 | if (options_.min_sdk_version_default && |
| 307 | el->FindAttribute(xml::kSchemaAndroid, "minSdkVersion") == nullptr) { |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 308 | // There was no minSdkVersion defined and we have a default to assign. |
| 309 | el->attributes.push_back( |
| 310 | xml::Attribute{xml::kSchemaAndroid, "minSdkVersion", |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 311 | options_.min_sdk_version_default.value()}); |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 312 | } |
| 313 | |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 314 | if (options_.target_sdk_version_default && |
| 315 | el->FindAttribute(xml::kSchemaAndroid, "targetSdkVersion") == nullptr) { |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 316 | // There was no targetSdkVersion defined and we have a default to assign. |
| 317 | el->attributes.push_back( |
| 318 | xml::Attribute{xml::kSchemaAndroid, "targetSdkVersion", |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 319 | options_.target_sdk_version_default.value()}); |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 320 | } |
| 321 | return true; |
| 322 | }); |
| 323 | |
| 324 | // Instrumentation actions. |
Adam Lesinski | 86d67df | 2017-01-31 13:47:27 -0800 | [diff] [blame] | 325 | manifest_action["instrumentation"].Action(RequiredNameIsJavaClassName); |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 326 | manifest_action["instrumentation"].Action([&](xml::Element* el) -> bool { |
| 327 | if (!options_.rename_instrumentation_target_package) { |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 328 | return true; |
| 329 | } |
| 330 | |
| 331 | if (xml::Attribute* attr = |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 332 | el->FindAttribute(xml::kSchemaAndroid, "targetPackage")) { |
| 333 | attr->value = options_.rename_instrumentation_target_package.value(); |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 334 | } |
| 335 | return true; |
| 336 | }); |
Adam Lesinski | 86d67df | 2017-01-31 13:47:27 -0800 | [diff] [blame] | 337 | manifest_action["instrumentation"]["meta-data"] = meta_data_action; |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 338 | |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 339 | manifest_action["original-package"]; |
MÃ¥rten Kongstad | c903d2e | 2016-12-09 00:23:41 +0100 | [diff] [blame] | 340 | manifest_action["overlay"]; |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 341 | manifest_action["protected-broadcast"]; |
Alan Viverette | cf5326f | 2018-01-05 16:03:50 -0500 | [diff] [blame] | 342 | manifest_action["adopt-permissions"]; |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 343 | manifest_action["uses-permission"]; |
Adam Lesinski | 4b585db | 2017-05-12 15:25:50 -0700 | [diff] [blame] | 344 | manifest_action["uses-permission-sdk-23"]; |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 345 | manifest_action["permission"]; |
Ryan Mitchell | 66f6cfb | 2018-07-25 16:15:17 -0700 | [diff] [blame] | 346 | manifest_action["permission"]["meta-data"] = meta_data_action; |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 347 | manifest_action["permission-tree"]; |
| 348 | manifest_action["permission-group"]; |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 349 | manifest_action["uses-configuration"]; |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 350 | manifest_action["supports-screens"]; |
Adam Lesinski | 86d67df | 2017-01-31 13:47:27 -0800 | [diff] [blame] | 351 | manifest_action["uses-feature"] = uses_feature_action; |
| 352 | manifest_action["feature-group"]["uses-feature"] = uses_feature_action; |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 353 | manifest_action["compatible-screens"]; |
| 354 | manifest_action["compatible-screens"]["screen"]; |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 355 | manifest_action["supports-gl-texture"]; |
Ryan Mitchell | 66f6cfb | 2018-07-25 16:15:17 -0700 | [diff] [blame] | 356 | manifest_action["restrict-update"]; |
| 357 | manifest_action["package-verifier"]; |
Adam Lesinski | 5119e51 | 2016-12-05 19:48:20 -0800 | [diff] [blame] | 358 | manifest_action["meta-data"] = meta_data_action; |
Adam Lesinski | b0c47ef | 2017-03-06 20:05:57 -0800 | [diff] [blame] | 359 | manifest_action["uses-split"].Action(RequiredNameIsJavaPackage); |
Adam Lesinski | 5119e51 | 2016-12-05 19:48:20 -0800 | [diff] [blame] | 360 | |
Adam Lesinski | 87f1e0f | 2017-06-27 16:21:58 -0700 | [diff] [blame] | 361 | manifest_action["key-sets"]["key-set"]["public-key"]; |
| 362 | manifest_action["key-sets"]["upgrade-key-set"]; |
| 363 | |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 364 | // Application actions. |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 365 | xml::XmlNodeAction& application_action = manifest_action["application"]; |
| 366 | application_action.Action(OptionalNameIsJavaClassName); |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 367 | |
Adam Lesinski | fca5e42 | 2017-12-20 15:03:36 -0800 | [diff] [blame] | 368 | application_action["uses-library"].Action(RequiredNameIsNotEmpty); |
| 369 | application_action["library"].Action(RequiredNameIsNotEmpty); |
Adam Lesinski | b5dc4bd | 2017-02-22 19:29:29 -0800 | [diff] [blame] | 370 | |
| 371 | xml::XmlNodeAction& static_library_action = application_action["static-library"]; |
| 372 | static_library_action.Action(RequiredNameIsJavaPackage); |
| 373 | static_library_action.Action(RequiredAndroidAttribute("version")); |
| 374 | |
| 375 | xml::XmlNodeAction& uses_static_library_action = application_action["uses-static-library"]; |
| 376 | uses_static_library_action.Action(RequiredNameIsJavaPackage); |
| 377 | uses_static_library_action.Action(RequiredAndroidAttribute("version")); |
| 378 | uses_static_library_action.Action(RequiredAndroidAttribute("certDigest")); |
Ryan Mitchell | 66f6cfb | 2018-07-25 16:15:17 -0700 | [diff] [blame] | 379 | uses_static_library_action["additional-certificate"]; |
Adam Lesinski | b5dc4bd | 2017-02-22 19:29:29 -0800 | [diff] [blame] | 380 | |
Dianne Hackborn | 813d750 | 2018-10-02 16:59:46 -0700 | [diff] [blame] | 381 | xml::XmlNodeAction& uses_package_action = application_action["uses-package"]; |
| 382 | uses_package_action.Action(RequiredNameIsJavaPackage); |
| 383 | uses_package_action["additional-certificate"]; |
| 384 | |
Ryan Mitchell | e5b38a6 | 2018-03-23 13:35:00 -0700 | [diff] [blame] | 385 | if (options_.debug_mode) { |
| 386 | application_action.Action([&](xml::Element* el) -> bool { |
| 387 | xml::Attribute *attr = el->FindOrCreateAttribute(xml::kSchemaAndroid, "debuggable"); |
| 388 | attr->value = "true"; |
| 389 | return true; |
| 390 | }); |
| 391 | } |
| 392 | |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 393 | application_action["meta-data"] = meta_data_action; |
Adam Lesinski | 7a917a2 | 2017-06-02 12:55:24 -0700 | [diff] [blame] | 394 | |
Adam Lesinski | 86d67df | 2017-01-31 13:47:27 -0800 | [diff] [blame] | 395 | application_action["activity"] = component_action; |
Adam Lesinski | 7a917a2 | 2017-06-02 12:55:24 -0700 | [diff] [blame] | 396 | application_action["activity"]["layout"]; |
| 397 | |
Adam Lesinski | 86d67df | 2017-01-31 13:47:27 -0800 | [diff] [blame] | 398 | application_action["activity-alias"] = component_action; |
| 399 | application_action["service"] = component_action; |
| 400 | application_action["receiver"] = component_action; |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 401 | |
| 402 | // Provider actions. |
Adam Lesinski | 86d67df | 2017-01-31 13:47:27 -0800 | [diff] [blame] | 403 | application_action["provider"] = component_action; |
Adam Lesinski | c10c0d0 | 2017-04-28 12:54:08 -0700 | [diff] [blame] | 404 | application_action["provider"]["grant-uri-permission"]; |
Adam Lesinski | 25783ca | 2017-04-24 13:33:47 -0700 | [diff] [blame] | 405 | application_action["provider"]["path-permission"]; |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 406 | |
Ryan Mitchell | 28afe68 | 2018-09-07 14:33:14 -0700 | [diff] [blame] | 407 | manifest_action["package"] = manifest_action; |
| 408 | |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 409 | return true; |
Adam Lesinski | 2ae4a87 | 2015-11-02 16:10:55 -0800 | [diff] [blame] | 410 | } |
| 411 | |
Adam Lesinski | 23034b9 | 2017-11-29 16:27:44 -0800 | [diff] [blame] | 412 | static void FullyQualifyClassName(const StringPiece& package, const StringPiece& attr_ns, |
| 413 | const StringPiece& attr_name, xml::Element* el) { |
| 414 | xml::Attribute* attr = el->FindAttribute(attr_ns, attr_name); |
| 415 | if (attr != nullptr) { |
| 416 | if (Maybe<std::string> new_value = util::GetFullyQualifiedClassName(package, attr->value)) { |
| 417 | attr->value = std::move(new_value.value()); |
Adam Lesinski | 52364f7 | 2016-01-11 13:10:24 -0800 | [diff] [blame] | 418 | } |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 419 | } |
Adam Lesinski | 23034b9 | 2017-11-29 16:27:44 -0800 | [diff] [blame] | 420 | } |
Adam Lesinski | 52364f7 | 2016-01-11 13:10:24 -0800 | [diff] [blame] | 421 | |
Adam Lesinski | b0c47ef | 2017-03-06 20:05:57 -0800 | [diff] [blame] | 422 | static bool RenameManifestPackage(const StringPiece& package_override, xml::Element* manifest_el) { |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 423 | xml::Attribute* attr = manifest_el->FindAttribute({}, "package"); |
Adam Lesinski | 52364f7 | 2016-01-11 13:10:24 -0800 | [diff] [blame] | 424 | |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 425 | // We've already verified that the manifest element is present, with a package |
| 426 | // name specified. |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 427 | CHECK(attr != nullptr); |
Adam Lesinski | 52364f7 | 2016-01-11 13:10:24 -0800 | [diff] [blame] | 428 | |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 429 | std::string original_package = std::move(attr->value); |
Adam Lesinski | d5083f6 | 2017-01-16 15:07:21 -0800 | [diff] [blame] | 430 | attr->value = package_override.to_string(); |
Adam Lesinski | 52364f7 | 2016-01-11 13:10:24 -0800 | [diff] [blame] | 431 | |
Adam Lesinski | 23034b9 | 2017-11-29 16:27:44 -0800 | [diff] [blame] | 432 | xml::Element* application_el = manifest_el->FindChild({}, "application"); |
| 433 | if (application_el != nullptr) { |
| 434 | FullyQualifyClassName(original_package, xml::kSchemaAndroid, "name", application_el); |
| 435 | FullyQualifyClassName(original_package, xml::kSchemaAndroid, "backupAgent", application_el); |
| 436 | |
| 437 | for (xml::Element* child_el : application_el->GetChildElements()) { |
| 438 | if (child_el->namespace_uri.empty()) { |
| 439 | if (child_el->name == "activity" || child_el->name == "activity-alias" || |
| 440 | child_el->name == "provider" || child_el->name == "receiver" || |
| 441 | child_el->name == "service") { |
| 442 | FullyQualifyClassName(original_package, xml::kSchemaAndroid, "name", child_el); |
| 443 | } |
| 444 | |
| 445 | if (child_el->name == "activity-alias") { |
| 446 | FullyQualifyClassName(original_package, xml::kSchemaAndroid, "targetActivity", child_el); |
| 447 | } |
| 448 | } |
| 449 | } |
| 450 | } |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 451 | return true; |
Adam Lesinski | 52364f7 | 2016-01-11 13:10:24 -0800 | [diff] [blame] | 452 | } |
| 453 | |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 454 | bool ManifestFixer::Consume(IAaptContext* context, xml::XmlResource* doc) { |
Fabien Sanglard | 2d34e76 | 2019-02-21 15:13:29 -0800 | [diff] [blame] | 455 | TRACE_CALL(); |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 456 | xml::Element* root = xml::FindRootElement(doc->root.get()); |
| 457 | if (!root || !root->namespace_uri.empty() || root->name != "manifest") { |
| 458 | context->GetDiagnostics()->Error(DiagMessage(doc->file.source) |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 459 | << "root tag must be <manifest>"); |
| 460 | return false; |
| 461 | } |
Adam Lesinski | 2ae4a87 | 2015-11-02 16:10:55 -0800 | [diff] [blame] | 462 | |
Adam Lesinski | b0c47ef | 2017-03-06 20:05:57 -0800 | [diff] [blame] | 463 | if ((options_.min_sdk_version_default || options_.target_sdk_version_default) && |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 464 | root->FindChild({}, "uses-sdk") == nullptr) { |
Adam Lesinski | e343eb1 | 2016-10-27 16:31:58 -0700 | [diff] [blame] | 465 | // Auto insert a <uses-sdk> element. This must be inserted before the |
| 466 | // <application> tag. The device runtime PackageParser will make SDK version |
| 467 | // decisions while parsing <application>. |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 468 | std::unique_ptr<xml::Element> uses_sdk = util::make_unique<xml::Element>(); |
| 469 | uses_sdk->name = "uses-sdk"; |
Adam Lesinski | e343eb1 | 2016-10-27 16:31:58 -0700 | [diff] [blame] | 470 | root->InsertChild(0, std::move(uses_sdk)); |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 471 | } |
Adam Lesinski | 2ae4a87 | 2015-11-02 16:10:55 -0800 | [diff] [blame] | 472 | |
Adam Lesinski | c628437 | 2017-12-04 13:46:23 -0800 | [diff] [blame] | 473 | if (options_.compile_sdk_version) { |
| 474 | xml::Attribute* attr = root->FindOrCreateAttribute(xml::kSchemaAndroid, "compileSdkVersion"); |
| 475 | |
| 476 | // Make sure we un-compile the value if it was set to something else. |
| 477 | attr->compiled_value = {}; |
Adam Lesinski | c628437 | 2017-12-04 13:46:23 -0800 | [diff] [blame] | 478 | attr->value = options_.compile_sdk_version.value(); |
Ryan Mitchell | aada89c | 2019-02-12 08:06:26 -0800 | [diff] [blame] | 479 | |
| 480 | attr = root->FindOrCreateAttribute("", "platformBuildVersionCode"); |
| 481 | |
| 482 | // Make sure we un-compile the value if it was set to something else. |
| 483 | attr->compiled_value = {}; |
| 484 | attr->value = options_.compile_sdk_version.value(); |
| 485 | |
Adam Lesinski | c628437 | 2017-12-04 13:46:23 -0800 | [diff] [blame] | 486 | } |
| 487 | |
| 488 | if (options_.compile_sdk_version_codename) { |
| 489 | xml::Attribute* attr = |
| 490 | root->FindOrCreateAttribute(xml::kSchemaAndroid, "compileSdkVersionCodename"); |
| 491 | |
| 492 | // Make sure we un-compile the value if it was set to something else. |
| 493 | attr->compiled_value = {}; |
Ryan Mitchell | aada89c | 2019-02-12 08:06:26 -0800 | [diff] [blame] | 494 | attr->value = options_.compile_sdk_version_codename.value(); |
Adam Lesinski | c628437 | 2017-12-04 13:46:23 -0800 | [diff] [blame] | 495 | |
Ryan Mitchell | aada89c | 2019-02-12 08:06:26 -0800 | [diff] [blame] | 496 | attr = root->FindOrCreateAttribute("", "platformBuildVersionName"); |
| 497 | |
| 498 | // Make sure we un-compile the value if it was set to something else. |
| 499 | attr->compiled_value = {}; |
Adam Lesinski | c628437 | 2017-12-04 13:46:23 -0800 | [diff] [blame] | 500 | attr->value = options_.compile_sdk_version_codename.value(); |
| 501 | } |
| 502 | |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 503 | xml::XmlActionExecutor executor; |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 504 | if (!BuildRules(&executor, context->GetDiagnostics())) { |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 505 | return false; |
| 506 | } |
Adam Lesinski | cc5609d | 2016-04-05 12:41:07 -0700 | [diff] [blame] | 507 | |
Izabela Orlowska | ad9e132 | 2017-12-19 16:22:42 +0000 | [diff] [blame] | 508 | xml::XmlActionExecutorPolicy policy = options_.warn_validation |
| 509 | ? xml::XmlActionExecutorPolicy::kWhitelistWarning |
| 510 | : xml::XmlActionExecutorPolicy::kWhitelist; |
| 511 | if (!executor.Execute(policy, context->GetDiagnostics(), doc)) { |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 512 | return false; |
| 513 | } |
Adam Lesinski | cc5609d | 2016-04-05 12:41:07 -0700 | [diff] [blame] | 514 | |
Adam Lesinski | ce5e56e | 2016-10-21 17:56:45 -0700 | [diff] [blame] | 515 | if (options_.rename_manifest_package) { |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 516 | // Rename manifest package outside of the XmlActionExecutor. |
Adam Lesinski | e343eb1 | 2016-10-27 16:31:58 -0700 | [diff] [blame] | 517 | // We need to extract the old package name and FullyQualify all class |
| 518 | // names. |
Adam Lesinski | b0c47ef | 2017-03-06 20:05:57 -0800 | [diff] [blame] | 519 | if (!RenameManifestPackage(options_.rename_manifest_package.value(), root)) { |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 520 | return false; |
Adam Lesinski | cc5609d | 2016-04-05 12:41:07 -0700 | [diff] [blame] | 521 | } |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 522 | } |
| 523 | return true; |
Adam Lesinski | 2ae4a87 | 2015-11-02 16:10:55 -0800 | [diff] [blame] | 524 | } |
| 525 | |
Adam Lesinski | cacb28f | 2016-10-19 12:18:14 -0700 | [diff] [blame] | 526 | } // namespace aapt |