1 /*
2 * Copyright (C) 2017 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 "cmd/Util.h"
18
19 #include <vector>
20
21 #include "android-base/logging.h"
22
23 #include "ConfigDescription.h"
24 #include "Locale.h"
25 #include "ResourceUtils.h"
26 #include "ValueVisitor.h"
27 #include "split/TableSplitter.h"
28 #include "util/Maybe.h"
29 #include "util/Util.h"
30
31 using ::android::StringPiece;
32
33 namespace aapt {
34
ParseTargetDensityParameter(const StringPiece & arg,IDiagnostics * diag)35 Maybe<uint16_t> ParseTargetDensityParameter(const StringPiece& arg, IDiagnostics* diag) {
36 ConfigDescription preferred_density_config;
37 if (!ConfigDescription::Parse(arg, &preferred_density_config)) {
38 diag->Error(DiagMessage() << "invalid density '" << arg << "' for --preferred-density option");
39 return {};
40 }
41
42 // Clear the version that can be automatically added.
43 preferred_density_config.sdkVersion = 0;
44
45 if (preferred_density_config.diff(ConfigDescription::DefaultConfig()) !=
46 ConfigDescription::CONFIG_DENSITY) {
47 diag->Error(DiagMessage() << "invalid preferred density '" << arg << "'. "
48 << "Preferred density must only be a density value");
49 return {};
50 }
51 return preferred_density_config.density;
52 }
53
ParseSplitParameter(const StringPiece & arg,IDiagnostics * diag,std::string * out_path,SplitConstraints * out_split)54 bool ParseSplitParameter(const StringPiece& arg, IDiagnostics* diag, std::string* out_path,
55 SplitConstraints* out_split) {
56 CHECK(diag != nullptr);
57 CHECK(out_path != nullptr);
58 CHECK(out_split != nullptr);
59
60 #ifdef _WIN32
61 const char sSeparator = ';';
62 #else
63 const char sSeparator = ':';
64 #endif
65
66 std::vector<std::string> parts = util::Split(arg, sSeparator);
67 if (parts.size() != 2) {
68 diag->Error(DiagMessage() << "invalid split parameter '" << arg << "'");
69 diag->Note(DiagMessage() << "should be --split path/to/output.apk" << sSeparator
70 << "<config>[,<config>...].");
71 return false;
72 }
73
74 *out_path = parts[0];
75 for (const StringPiece& config_str : util::Tokenize(parts[1], ',')) {
76 ConfigDescription config;
77 if (!ConfigDescription::Parse(config_str, &config)) {
78 diag->Error(DiagMessage() << "invalid config '" << config_str << "' in split parameter '"
79 << arg << "'");
80 return false;
81 }
82 out_split->configs.insert(config);
83 }
84 return true;
85 }
86
ParseConfigFilterParameters(const std::vector<std::string> & args,IDiagnostics * diag)87 std::unique_ptr<IConfigFilter> ParseConfigFilterParameters(const std::vector<std::string>& args,
88 IDiagnostics* diag) {
89 std::unique_ptr<AxisConfigFilter> filter = util::make_unique<AxisConfigFilter>();
90 for (const std::string& config_arg : args) {
91 for (const StringPiece& config_str : util::Tokenize(config_arg, ',')) {
92 ConfigDescription config;
93 LocaleValue lv;
94 if (lv.InitFromFilterString(config_str)) {
95 lv.WriteTo(&config);
96 } else if (!ConfigDescription::Parse(config_str, &config)) {
97 diag->Error(DiagMessage() << "invalid config '" << config_str << "' for -c option");
98 return {};
99 }
100
101 if (config.density != 0) {
102 diag->Warn(DiagMessage() << "ignoring density '" << config << "' for -c option");
103 } else {
104 filter->AddConfig(config);
105 }
106 }
107 }
108 return std::move(filter);
109 }
110
111 // Adjust the SplitConstraints so that their SDK version is stripped if it
112 // is less than or equal to the minSdk. Otherwise the resources that have had
113 // their SDK version stripped due to minSdk won't ever match.
AdjustSplitConstraintsForMinSdk(int min_sdk,const std::vector<SplitConstraints> & split_constraints)114 std::vector<SplitConstraints> AdjustSplitConstraintsForMinSdk(
115 int min_sdk, const std::vector<SplitConstraints>& split_constraints) {
116 std::vector<SplitConstraints> adjusted_constraints;
117 adjusted_constraints.reserve(split_constraints.size());
118 for (const SplitConstraints& constraints : split_constraints) {
119 SplitConstraints constraint;
120 for (const ConfigDescription& config : constraints.configs) {
121 if (config.sdkVersion <= min_sdk) {
122 constraint.configs.insert(config.CopyWithoutSdkVersion());
123 } else {
124 constraint.configs.insert(config);
125 }
126 }
127 adjusted_constraints.push_back(std::move(constraint));
128 }
129 return adjusted_constraints;
130 }
131
CreateAttributeWithId(const ResourceId & id)132 static xml::AaptAttribute CreateAttributeWithId(const ResourceId& id) {
133 return xml::AaptAttribute(Attribute(), id);
134 }
135
CreateAndroidNamespaceDecl()136 static xml::NamespaceDecl CreateAndroidNamespaceDecl() {
137 xml::NamespaceDecl decl;
138 decl.prefix = "android";
139 decl.uri = xml::kSchemaAndroid;
140 return decl;
141 }
142
143 // Returns a copy of 'name' which conforms to the regex '[a-zA-Z]+[a-zA-Z0-9_]*' by
144 // replacing nonconforming characters with underscores.
145 //
146 // See frameworks/base/core/java/android/content/pm/PackageParser.java which
147 // checks this at runtime.
MakePackageSafeName(const std::string & name)148 static std::string MakePackageSafeName(const std::string &name) {
149 std::string result(name);
150 bool first = true;
151 for (char &c : result) {
152 if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')) {
153 first = false;
154 continue;
155 }
156 if (!first) {
157 if (c >= '0' && c <= '9') {
158 continue;
159 }
160 }
161
162 c = '_';
163 first = false;
164 }
165 return result;
166 }
167
GenerateSplitManifest(const AppInfo & app_info,const SplitConstraints & constraints)168 std::unique_ptr<xml::XmlResource> GenerateSplitManifest(const AppInfo& app_info,
169 const SplitConstraints& constraints) {
170 const ResourceId kVersionCode(0x0101021b);
171 const ResourceId kRevisionCode(0x010104d5);
172 const ResourceId kHasCode(0x0101000c);
173
174 std::unique_ptr<xml::Element> manifest_el = util::make_unique<xml::Element>();
175 manifest_el->namespace_decls.push_back(CreateAndroidNamespaceDecl());
176 manifest_el->name = "manifest";
177 manifest_el->attributes.push_back(xml::Attribute{"", "package", app_info.package});
178
179 if (app_info.version_code) {
180 const uint32_t version_code = app_info.version_code.value();
181 manifest_el->attributes.push_back(xml::Attribute{
182 xml::kSchemaAndroid, "versionCode", std::to_string(version_code),
183 CreateAttributeWithId(kVersionCode),
184 util::make_unique<BinaryPrimitive>(android::Res_value::TYPE_INT_DEC, version_code)});
185 }
186
187 if (app_info.revision_code) {
188 const uint32_t revision_code = app_info.revision_code.value();
189 manifest_el->attributes.push_back(xml::Attribute{
190 xml::kSchemaAndroid, "revisionCode", std::to_string(revision_code),
191 CreateAttributeWithId(kRevisionCode),
192 util::make_unique<BinaryPrimitive>(android::Res_value::TYPE_INT_DEC, revision_code)});
193 }
194
195 std::stringstream split_name;
196 if (app_info.split_name) {
197 split_name << app_info.split_name.value() << ".";
198 }
199 std::vector<std::string> sanitized_config_names;
200 for (const auto &config : constraints.configs) {
201 sanitized_config_names.push_back(MakePackageSafeName(config.toString().string()));
202 }
203 split_name << "config." << util::Joiner(sanitized_config_names, "_");
204
205 manifest_el->attributes.push_back(xml::Attribute{"", "split", split_name.str()});
206
207 if (app_info.split_name) {
208 manifest_el->attributes.push_back(
209 xml::Attribute{"", "configForSplit", app_info.split_name.value()});
210 }
211
212 // Splits may contain more configurations than originally desired (fall-back densities, etc.).
213 // This makes programmatic discovery of split targeting difficult. Encode the original
214 // split constraints intended for this split.
215 std::stringstream target_config_str;
216 target_config_str << util::Joiner(constraints.configs, ",");
217 manifest_el->attributes.push_back(xml::Attribute{"", "targetConfig", target_config_str.str()});
218
219 std::unique_ptr<xml::Element> application_el = util::make_unique<xml::Element>();
220 application_el->name = "application";
221 application_el->attributes.push_back(
222 xml::Attribute{xml::kSchemaAndroid, "hasCode", "false", CreateAttributeWithId(kHasCode),
223 util::make_unique<BinaryPrimitive>(android::Res_value::TYPE_INT_BOOLEAN, 0u)});
224
225 manifest_el->AppendChild(std::move(application_el));
226
227 std::unique_ptr<xml::XmlResource> doc = util::make_unique<xml::XmlResource>();
228 doc->root = std::move(manifest_el);
229 return doc;
230 }
231
ExtractCompiledString(const xml::Attribute & attr,std::string * out_error)232 static Maybe<std::string> ExtractCompiledString(const xml::Attribute& attr,
233 std::string* out_error) {
234 if (attr.compiled_value != nullptr) {
235 const String* compiled_str = ValueCast<String>(attr.compiled_value.get());
236 if (compiled_str != nullptr) {
237 if (!compiled_str->value->empty()) {
238 return *compiled_str->value;
239 } else {
240 *out_error = "compiled value is an empty string";
241 return {};
242 }
243 }
244 *out_error = "compiled value is not a string";
245 return {};
246 }
247
248 // Fallback to the plain text value if there is one.
249 if (!attr.value.empty()) {
250 return attr.value;
251 }
252 *out_error = "value is an empty string";
253 return {};
254 }
255
ExtractCompiledInt(const xml::Attribute & attr,std::string * out_error)256 static Maybe<uint32_t> ExtractCompiledInt(const xml::Attribute& attr, std::string* out_error) {
257 if (attr.compiled_value != nullptr) {
258 const BinaryPrimitive* compiled_prim = ValueCast<BinaryPrimitive>(attr.compiled_value.get());
259 if (compiled_prim != nullptr) {
260 if (compiled_prim->value.dataType >= android::Res_value::TYPE_FIRST_INT &&
261 compiled_prim->value.dataType <= android::Res_value::TYPE_LAST_INT) {
262 return compiled_prim->value.data;
263 }
264 }
265 *out_error = "compiled value is not an integer";
266 return {};
267 }
268
269 // Fallback to the plain text value if there is one.
270 Maybe<uint32_t> integer = ResourceUtils::ParseInt(attr.value);
271 if (integer) {
272 return integer;
273 }
274 std::stringstream error_msg;
275 error_msg << "'" << attr.value << "' is not a valid integer";
276 *out_error = error_msg.str();
277 return {};
278 }
279
ExtractSdkVersion(const xml::Attribute & attr,std::string * out_error)280 static Maybe<int> ExtractSdkVersion(const xml::Attribute& attr, std::string* out_error) {
281 if (attr.compiled_value != nullptr) {
282 const BinaryPrimitive* compiled_prim = ValueCast<BinaryPrimitive>(attr.compiled_value.get());
283 if (compiled_prim != nullptr) {
284 if (compiled_prim->value.dataType >= android::Res_value::TYPE_FIRST_INT &&
285 compiled_prim->value.dataType <= android::Res_value::TYPE_LAST_INT) {
286 return compiled_prim->value.data;
287 }
288 *out_error = "compiled value is not an integer or string";
289 return {};
290 }
291
292 const String* compiled_str = ValueCast<String>(attr.compiled_value.get());
293 if (compiled_str != nullptr) {
294 Maybe<int> sdk_version = ResourceUtils::ParseSdkVersion(*compiled_str->value);
295 if (sdk_version) {
296 return sdk_version;
297 }
298
299 *out_error = "compiled string value is not a valid SDK version";
300 return {};
301 }
302 *out_error = "compiled value is not an integer or string";
303 return {};
304 }
305
306 // Fallback to the plain text value if there is one.
307 Maybe<int> sdk_version = ResourceUtils::ParseSdkVersion(attr.value);
308 if (sdk_version) {
309 return sdk_version;
310 }
311 std::stringstream error_msg;
312 error_msg << "'" << attr.value << "' is not a valid SDK version";
313 *out_error = error_msg.str();
314 return {};
315 }
316
ExtractAppInfoFromBinaryManifest(const xml::XmlResource & xml_res,IDiagnostics * diag)317 Maybe<AppInfo> ExtractAppInfoFromBinaryManifest(const xml::XmlResource& xml_res,
318 IDiagnostics* diag) {
319 // Make sure the first element is <manifest> with package attribute.
320 const xml::Element* manifest_el = xml_res.root.get();
321 if (manifest_el == nullptr) {
322 return {};
323 }
324
325 AppInfo app_info;
326
327 if (!manifest_el->namespace_uri.empty() || manifest_el->name != "manifest") {
328 diag->Error(DiagMessage(xml_res.file.source) << "root tag must be <manifest>");
329 return {};
330 }
331
332 const xml::Attribute* package_attr = manifest_el->FindAttribute({}, "package");
333 if (!package_attr) {
334 diag->Error(DiagMessage(xml_res.file.source) << "<manifest> must have a 'package' attribute");
335 return {};
336 }
337
338 std::string error_msg;
339 Maybe<std::string> maybe_package = ExtractCompiledString(*package_attr, &error_msg);
340 if (!maybe_package) {
341 diag->Error(DiagMessage(xml_res.file.source.WithLine(manifest_el->line_number))
342 << "invalid package name: " << error_msg);
343 return {};
344 }
345 app_info.package = maybe_package.value();
346
347 if (const xml::Attribute* version_code_attr =
348 manifest_el->FindAttribute(xml::kSchemaAndroid, "versionCode")) {
349 Maybe<uint32_t> maybe_code = ExtractCompiledInt(*version_code_attr, &error_msg);
350 if (!maybe_code) {
351 diag->Error(DiagMessage(xml_res.file.source.WithLine(manifest_el->line_number))
352 << "invalid android:versionCode: " << error_msg);
353 return {};
354 }
355 app_info.version_code = maybe_code.value();
356 }
357
358 if (const xml::Attribute* revision_code_attr =
359 manifest_el->FindAttribute(xml::kSchemaAndroid, "revisionCode")) {
360 Maybe<uint32_t> maybe_code = ExtractCompiledInt(*revision_code_attr, &error_msg);
361 if (!maybe_code) {
362 diag->Error(DiagMessage(xml_res.file.source.WithLine(manifest_el->line_number))
363 << "invalid android:revisionCode: " << error_msg);
364 return {};
365 }
366 app_info.revision_code = maybe_code.value();
367 }
368
369 if (const xml::Attribute* split_name_attr = manifest_el->FindAttribute({}, "split")) {
370 Maybe<std::string> maybe_split_name = ExtractCompiledString(*split_name_attr, &error_msg);
371 if (!maybe_split_name) {
372 diag->Error(DiagMessage(xml_res.file.source.WithLine(manifest_el->line_number))
373 << "invalid split name: " << error_msg);
374 return {};
375 }
376 app_info.split_name = maybe_split_name.value();
377 }
378
379 if (const xml::Element* uses_sdk_el = manifest_el->FindChild({}, "uses-sdk")) {
380 if (const xml::Attribute* min_sdk =
381 uses_sdk_el->FindAttribute(xml::kSchemaAndroid, "minSdkVersion")) {
382 Maybe<int> maybe_sdk = ExtractSdkVersion(*min_sdk, &error_msg);
383 if (!maybe_sdk) {
384 diag->Error(DiagMessage(xml_res.file.source.WithLine(uses_sdk_el->line_number))
385 << "invalid android:minSdkVersion: " << error_msg);
386 return {};
387 }
388 app_info.min_sdk_version = maybe_sdk.value();
389 }
390 }
391 return app_info;
392 }
393
394 } // namespace aapt
395