blob: 1fc2233d08f9814cdf266a8a8fa0e0d118e3e7de [file] [log] [blame]
Jiyong Park09d77522019-11-18 11:16:27 +09001// Copyright (C) 2019 The Android Open Source Project
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15package apex
16
17import (
Jiyong Parkd93e1b12020-02-28 15:22:21 +090018 "encoding/json"
Jiyong Park09d77522019-11-18 11:16:27 +090019 "fmt"
20 "path/filepath"
21 "runtime"
22 "sort"
Jooyung Han23b0adf2020-03-12 18:37:20 +090023 "strconv"
Jiyong Park09d77522019-11-18 11:16:27 +090024 "strings"
25
26 "android/soong/android"
27 "android/soong/java"
28
29 "github.com/google/blueprint"
30 "github.com/google/blueprint/proptools"
31)
32
33var (
34 pctx = android.NewPackageContext("android/apex")
35)
36
37func init() {
38 pctx.Import("android/soong/android")
39 pctx.Import("android/soong/java")
40 pctx.HostBinToolVariable("apexer", "apexer")
41 // ART minimal builds (using the master-art manifest) do not have the "frameworks/base"
42 // projects, and hence cannot built 'aapt2'. Use the SDK prebuilt instead.
43 hostBinToolVariableWithPrebuilt := func(name, prebuiltDir, tool string) {
44 pctx.VariableFunc(name, func(ctx android.PackageVarContext) string {
45 if !ctx.Config().FrameworksBaseDirExists(ctx) {
46 return filepath.Join(prebuiltDir, runtime.GOOS, "bin", tool)
47 } else {
Martin Stjernholm7260d062019-12-09 21:47:14 +000048 return ctx.Config().HostToolPath(ctx, tool).String()
Jiyong Park09d77522019-11-18 11:16:27 +090049 }
50 })
51 }
52 hostBinToolVariableWithPrebuilt("aapt2", "prebuilts/sdk/tools", "aapt2")
53 pctx.HostBinToolVariable("avbtool", "avbtool")
54 pctx.HostBinToolVariable("e2fsdroid", "e2fsdroid")
55 pctx.HostBinToolVariable("merge_zips", "merge_zips")
56 pctx.HostBinToolVariable("mke2fs", "mke2fs")
57 pctx.HostBinToolVariable("resize2fs", "resize2fs")
58 pctx.HostBinToolVariable("sefcontext_compile", "sefcontext_compile")
59 pctx.HostBinToolVariable("soong_zip", "soong_zip")
60 pctx.HostBinToolVariable("zip2zip", "zip2zip")
61 pctx.HostBinToolVariable("zipalign", "zipalign")
62 pctx.HostBinToolVariable("jsonmodify", "jsonmodify")
63 pctx.HostBinToolVariable("conv_apex_manifest", "conv_apex_manifest")
64}
65
66var (
67 // Create a canned fs config file where all files and directories are
68 // by default set to (uid/gid/mode) = (1000/1000/0644)
69 // TODO(b/113082813) make this configurable using config.fs syntax
70 generateFsConfig = pctx.StaticRule("generateFsConfig", blueprint.RuleParams{
71 Command: `echo '/ 1000 1000 0755' > ${out} && ` +
72 `echo ${ro_paths} | tr ' ' '\n' | awk '{print "/"$$1 " 1000 1000 0644"}' >> ${out} && ` +
73 `echo ${exec_paths} | tr ' ' '\n' | awk '{print "/"$$1 " 0 2000 0755"}' >> ${out}`,
74 Description: "fs_config ${out}",
75 }, "ro_paths", "exec_paths")
76
77 apexManifestRule = pctx.StaticRule("apexManifestRule", blueprint.RuleParams{
78 Command: `rm -f $out && ${jsonmodify} $in ` +
79 `-a provideNativeLibs ${provideNativeLibs} ` +
80 `-a requireNativeLibs ${requireNativeLibs} ` +
81 `${opt} ` +
82 `-o $out`,
83 CommandDeps: []string{"${jsonmodify}"},
84 Description: "prepare ${out}",
85 }, "provideNativeLibs", "requireNativeLibs", "opt")
86
87 stripApexManifestRule = pctx.StaticRule("stripApexManifestRule", blueprint.RuleParams{
88 Command: `rm -f $out && ${conv_apex_manifest} strip $in -o $out`,
89 CommandDeps: []string{"${conv_apex_manifest}"},
90 Description: "strip ${in}=>${out}",
91 })
92
93 pbApexManifestRule = pctx.StaticRule("pbApexManifestRule", blueprint.RuleParams{
94 Command: `rm -f $out && ${conv_apex_manifest} proto $in -o $out`,
95 CommandDeps: []string{"${conv_apex_manifest}"},
96 Description: "convert ${in}=>${out}",
97 })
98
99 // TODO(b/113233103): make sure that file_contexts is sane, i.e., validate
100 // against the binary policy using sefcontext_compiler -p <policy>.
101
102 // TODO(b/114327326): automate the generation of file_contexts
103 apexRule = pctx.StaticRule("apexRule", blueprint.RuleParams{
104 Command: `rm -rf ${image_dir} && mkdir -p ${image_dir} && ` +
105 `(. ${out}.copy_commands) && ` +
106 `APEXER_TOOL_PATH=${tool_path} ` +
107 `${apexer} --force --manifest ${manifest} ` +
Jiyong Park09d77522019-11-18 11:16:27 +0900108 `--file_contexts ${file_contexts} ` +
109 `--canned_fs_config ${canned_fs_config} ` +
Dario Freni0f4ae072020-01-02 15:24:12 +0000110 `--include_build_info ` +
Jiyong Park09d77522019-11-18 11:16:27 +0900111 `--payload_type image ` +
112 `--key ${key} ${opt_flags} ${image_dir} ${out} `,
113 CommandDeps: []string{"${apexer}", "${avbtool}", "${e2fsdroid}", "${merge_zips}",
114 "${mke2fs}", "${resize2fs}", "${sefcontext_compile}",
115 "${soong_zip}", "${zipalign}", "${aapt2}", "prebuilts/sdk/current/public/android.jar"},
116 Rspfile: "${out}.copy_commands",
117 RspfileContent: "${copy_commands}",
118 Description: "APEX ${image_dir} => ${out}",
Jooyung Han214bf372019-11-12 13:03:50 +0900119 }, "tool_path", "image_dir", "copy_commands", "file_contexts", "canned_fs_config", "key", "opt_flags", "manifest")
Jiyong Park09d77522019-11-18 11:16:27 +0900120
121 zipApexRule = pctx.StaticRule("zipApexRule", blueprint.RuleParams{
122 Command: `rm -rf ${image_dir} && mkdir -p ${image_dir} && ` +
123 `(. ${out}.copy_commands) && ` +
124 `APEXER_TOOL_PATH=${tool_path} ` +
Jooyung Han214bf372019-11-12 13:03:50 +0900125 `${apexer} --force --manifest ${manifest} ` +
Jiyong Park09d77522019-11-18 11:16:27 +0900126 `--payload_type zip ` +
127 `${image_dir} ${out} `,
128 CommandDeps: []string{"${apexer}", "${merge_zips}", "${soong_zip}", "${zipalign}", "${aapt2}"},
129 Rspfile: "${out}.copy_commands",
130 RspfileContent: "${copy_commands}",
131 Description: "ZipAPEX ${image_dir} => ${out}",
Jooyung Han214bf372019-11-12 13:03:50 +0900132 }, "tool_path", "image_dir", "copy_commands", "manifest")
Jiyong Park09d77522019-11-18 11:16:27 +0900133
134 apexProtoConvertRule = pctx.AndroidStaticRule("apexProtoConvertRule",
135 blueprint.RuleParams{
136 Command: `${aapt2} convert --output-format proto $in -o $out`,
137 CommandDeps: []string{"${aapt2}"},
138 })
139
140 apexBundleRule = pctx.StaticRule("apexBundleRule", blueprint.RuleParams{
Jiyong Parkd93e1b12020-02-28 15:22:21 +0900141 Command: `${zip2zip} -i $in -o $out.base ` +
Jiyong Park09d77522019-11-18 11:16:27 +0900142 `apex_payload.img:apex/${abi}.img ` +
Dario Freni18423782020-03-02 21:47:09 +0000143 `apex_build_info.pb:apex/${abi}.build_info.pb ` +
Jiyong Park09d77522019-11-18 11:16:27 +0900144 `apex_manifest.json:root/apex_manifest.json ` +
Jiyong Park53ae3342019-12-08 02:06:24 +0900145 `apex_manifest.pb:root/apex_manifest.pb ` +
Jiyong Park09d77522019-11-18 11:16:27 +0900146 `AndroidManifest.xml:manifest/AndroidManifest.xml ` +
Jiyong Parkd93e1b12020-02-28 15:22:21 +0900147 `assets/NOTICE.html.gz:assets/NOTICE.html.gz &&` +
148 `${soong_zip} -o $out.config -C $$(dirname ${config}) -f ${config} && ` +
149 `${merge_zips} $out $out.base $out.config`,
150 CommandDeps: []string{"${zip2zip}", "${soong_zip}", "${merge_zips}"},
Jiyong Park09d77522019-11-18 11:16:27 +0900151 Description: "app bundle",
Jiyong Parkd93e1b12020-02-28 15:22:21 +0900152 }, "abi", "config")
Jiyong Park09d77522019-11-18 11:16:27 +0900153
154 emitApexContentRule = pctx.StaticRule("emitApexContentRule", blueprint.RuleParams{
155 Command: `rm -f ${out} && touch ${out} && (. ${out}.emit_commands)`,
156 Rspfile: "${out}.emit_commands",
157 RspfileContent: "${emit_commands}",
158 Description: "Emit APEX image content",
159 }, "emit_commands")
160
161 diffApexContentRule = pctx.StaticRule("diffApexContentRule", blueprint.RuleParams{
162 Command: `diff --unchanged-group-format='' \` +
163 `--changed-group-format='%<' \` +
164 `${image_content_file} ${whitelisted_files_file} || (` +
165 `echo -e "New unexpected files were added to ${apex_module_name}." ` +
166 ` "To fix the build run following command:" && ` +
167 `echo "system/apex/tools/update_whitelist.sh ${whitelisted_files_file} ${image_content_file}" && ` +
Dan Willemsen81e43c52020-01-28 15:40:19 -0800168 `exit 1); touch ${out}`,
Jiyong Park09d77522019-11-18 11:16:27 +0900169 Description: "Diff ${image_content_file} and ${whitelisted_files_file}",
170 }, "image_content_file", "whitelisted_files_file", "apex_module_name")
171)
172
173func (a *apexBundle) buildManifest(ctx android.ModuleContext, provideNativeLibs, requireNativeLibs []string) {
174 manifestSrc := android.PathForModuleSrc(ctx, proptools.StringDefault(a.properties.Manifest, "apex_manifest.json"))
175
Jooyung Han214bf372019-11-12 13:03:50 +0900176 manifestJsonFullOut := android.PathForModuleOut(ctx, "apex_manifest_full.json")
Jiyong Park09d77522019-11-18 11:16:27 +0900177
178 // put dependency({provide|require}NativeLibs) in apex_manifest.json
179 provideNativeLibs = android.SortedUniqueStrings(provideNativeLibs)
180 requireNativeLibs = android.SortedUniqueStrings(android.RemoveListFromList(requireNativeLibs, provideNativeLibs))
181
182 // apex name can be overridden
183 optCommands := []string{}
184 if a.properties.Apex_name != nil {
185 optCommands = append(optCommands, "-v name "+*a.properties.Apex_name)
186 }
187
188 ctx.Build(pctx, android.BuildParams{
189 Rule: apexManifestRule,
190 Input: manifestSrc,
Jooyung Han214bf372019-11-12 13:03:50 +0900191 Output: manifestJsonFullOut,
Jiyong Park09d77522019-11-18 11:16:27 +0900192 Args: map[string]string{
193 "provideNativeLibs": strings.Join(provideNativeLibs, " "),
194 "requireNativeLibs": strings.Join(requireNativeLibs, " "),
195 "opt": strings.Join(optCommands, " "),
196 },
197 })
198
Jooyung Han23b0adf2020-03-12 18:37:20 +0900199 if a.minSdkVersion(ctx) == android.SdkVersion_Android10 {
Jooyung Han214bf372019-11-12 13:03:50 +0900200 // b/143654022 Q apexd can't understand newly added keys in apex_manifest.json
201 // prepare stripped-down version so that APEX modules built from R+ can be installed to Q
202 a.manifestJsonOut = android.PathForModuleOut(ctx, "apex_manifest.json")
203 ctx.Build(pctx, android.BuildParams{
204 Rule: stripApexManifestRule,
205 Input: manifestJsonFullOut,
206 Output: a.manifestJsonOut,
207 })
208 }
Jiyong Park09d77522019-11-18 11:16:27 +0900209
210 // from R+, protobuf binary format (.pb) is the standard format for apex_manifest
211 a.manifestPbOut = android.PathForModuleOut(ctx, "apex_manifest.pb")
212 ctx.Build(pctx, android.BuildParams{
213 Rule: pbApexManifestRule,
Jooyung Han214bf372019-11-12 13:03:50 +0900214 Input: manifestJsonFullOut,
Jiyong Park09d77522019-11-18 11:16:27 +0900215 Output: a.manifestPbOut,
216 })
217}
218
Jiyong Park19972c72020-01-28 20:05:29 +0900219func (a *apexBundle) buildNoticeFiles(ctx android.ModuleContext, apexFileName string) android.NoticeOutputs {
Jiyong Park162e8442020-03-17 19:16:40 +0900220 var noticeFiles android.Paths
221
222 a.walkPayloadDeps(ctx, func(ctx android.ModuleContext, from blueprint.Module, to android.ApexModule, externalDep bool) {
223 if externalDep {
224 return
Jiyong Park09d77522019-11-18 11:16:27 +0900225 }
Jiyong Park162e8442020-03-17 19:16:40 +0900226 notice := to.NoticeFile()
227 if notice.Valid() {
228 noticeFiles = append(noticeFiles, notice.Path())
229 }
230 })
Jiyong Park09d77522019-11-18 11:16:27 +0900231
232 if len(noticeFiles) == 0 {
Jiyong Park19972c72020-01-28 20:05:29 +0900233 return android.NoticeOutputs{}
Jiyong Park09d77522019-11-18 11:16:27 +0900234 }
235
Jiyong Park19972c72020-01-28 20:05:29 +0900236 return android.BuildNoticeOutput(ctx, a.installDir, apexFileName, android.FirstUniquePaths(noticeFiles))
Jiyong Park09d77522019-11-18 11:16:27 +0900237}
238
Jiyong Park3a1602e2020-01-14 14:39:19 +0900239func (a *apexBundle) buildInstalledFilesFile(ctx android.ModuleContext, builtApex android.Path, imageDir android.Path) android.OutputPath {
240 output := android.PathForModuleOut(ctx, "installed-files.txt")
241 rule := android.NewRuleBuilder()
242 rule.Command().
243 Implicit(builtApex).
244 Text("(cd " + imageDir.String() + " ; ").
Jiyong Parkbd63a102020-02-08 12:40:05 +0900245 Text("find . \\( -type f -o -type l \\) -printf \"%s %p\\n\") ").
Jiyong Park3a1602e2020-01-14 14:39:19 +0900246 Text(" | sort -nr > ").
247 Output(output)
248 rule.Build(pctx, ctx, "installed-files."+a.Name(), "Installed files")
249 return output.OutputPath
250}
251
Jiyong Parkd93e1b12020-02-28 15:22:21 +0900252func (a *apexBundle) buildBundleConfig(ctx android.ModuleContext) android.OutputPath {
253 output := android.PathForModuleOut(ctx, "bundle_config.json")
254
Jiyong Parkaf8998c2020-02-28 16:51:07 +0900255 type ApkConfig struct {
256 Package_name string `json:"package_name"`
257 Apk_path string `json:"path"`
258 }
Jiyong Parkd93e1b12020-02-28 15:22:21 +0900259 config := struct {
260 Compression struct {
261 Uncompressed_glob []string `json:"uncompressed_glob"`
262 } `json:"compression"`
Jiyong Parkaf8998c2020-02-28 16:51:07 +0900263 Apex_config struct {
264 Apex_embedded_apk_config []ApkConfig `json:"apex_embedded_apk_config,omitempty"`
265 } `json:"apex_config,omitempty"`
Jiyong Parkd93e1b12020-02-28 15:22:21 +0900266 }{}
267
268 config.Compression.Uncompressed_glob = []string{
269 "apex_payload.img",
270 "apex_manifest.*",
271 }
Jiyong Parkaf8998c2020-02-28 16:51:07 +0900272
273 // collect the manifest names and paths of android apps
274 // if their manifest names are overridden
275 for _, fi := range a.filesInfo {
276 if fi.class != app {
277 continue
278 }
279 packageName := fi.overriddenPackageName
280 if packageName != "" {
281 config.Apex_config.Apex_embedded_apk_config = append(
282 config.Apex_config.Apex_embedded_apk_config,
283 ApkConfig{
284 Package_name: packageName,
285 Apk_path: fi.Path(),
286 })
287 }
288 }
289
Jiyong Parkd93e1b12020-02-28 15:22:21 +0900290 j, err := json.Marshal(config)
291 if err != nil {
292 panic(fmt.Errorf("error while marshalling to %q: %#v", output, err))
293 }
294
295 ctx.Build(pctx, android.BuildParams{
296 Rule: android.WriteFile,
297 Output: output,
298 Description: "Bundle Config " + output.String(),
299 Args: map[string]string{
300 "content": string(j),
301 },
302 })
303
304 return output.OutputPath
305}
306
Jiyong Park09d77522019-11-18 11:16:27 +0900307func (a *apexBundle) buildUnflattenedApex(ctx android.ModuleContext) {
308 var abis []string
309 for _, target := range ctx.MultiTargets() {
310 if len(target.Arch.Abi) > 0 {
311 abis = append(abis, target.Arch.Abi[0])
312 }
313 }
314
315 abis = android.FirstUniqueStrings(abis)
316
317 apexType := a.properties.ApexType
318 suffix := apexType.suffix()
Jiyong Park7cd10e32020-01-14 09:22:18 +0900319 var implicitInputs []android.Path
Jaewoong Jung1670ca02019-11-22 14:50:42 -0800320 unsignedOutputFile := android.PathForModuleOut(ctx, a.Name()+suffix+".unsigned")
Jiyong Park09d77522019-11-18 11:16:27 +0900321
Jiyong Park7cd10e32020-01-14 09:22:18 +0900322 // TODO(jiyong): construct the copy rules using RuleBuilder
323 var copyCommands []string
324 for _, fi := range a.filesInfo {
325 destPath := android.PathForModuleOut(ctx, "image"+suffix, fi.Path()).String()
326 copyCommands = append(copyCommands, "mkdir -p "+filepath.Dir(destPath))
327 if a.linkToSystemLib && fi.transitiveDep && fi.AvailableToPlatform() {
328 // TODO(jiyong): pathOnDevice should come from fi.module, not being calculated here
329 pathOnDevice := filepath.Join("/system", fi.Path())
330 copyCommands = append(copyCommands, "ln -sfn "+pathOnDevice+" "+destPath)
331 } else {
332 copyCommands = append(copyCommands, "cp -f "+fi.builtFile.String()+" "+destPath)
333 implicitInputs = append(implicitInputs, fi.builtFile)
334 }
335 // create additional symlinks pointing the file inside the APEX
336 for _, symlinkPath := range fi.SymlinkPaths() {
337 symlinkDest := android.PathForModuleOut(ctx, "image"+suffix, symlinkPath).String()
338 copyCommands = append(copyCommands, "ln -sfn "+filepath.Base(destPath)+" "+symlinkDest)
339 }
Jiyong Park09d77522019-11-18 11:16:27 +0900340 }
341
Jiyong Park7cd10e32020-01-14 09:22:18 +0900342 // TODO(jiyong): use RuleBuilder
343 var emitCommands []string
344 imageContentFile := android.PathForModuleOut(ctx, "content.txt")
Jooyung Han214bf372019-11-12 13:03:50 +0900345 emitCommands = append(emitCommands, "echo ./apex_manifest.pb >> "+imageContentFile.String())
Jooyung Han23b0adf2020-03-12 18:37:20 +0900346 if a.minSdkVersion(ctx) == android.SdkVersion_Android10 {
Jooyung Han214bf372019-11-12 13:03:50 +0900347 emitCommands = append(emitCommands, "echo ./apex_manifest.json >> "+imageContentFile.String())
348 }
Jiyong Park7cd10e32020-01-14 09:22:18 +0900349 for _, fi := range a.filesInfo {
350 emitCommands = append(emitCommands, "echo './"+fi.Path()+"' >> "+imageContentFile.String())
Jiyong Park09d77522019-11-18 11:16:27 +0900351 }
352 emitCommands = append(emitCommands, "sort -o "+imageContentFile.String()+" "+imageContentFile.String())
Jooyung Han214bf372019-11-12 13:03:50 +0900353 implicitInputs = append(implicitInputs, a.manifestPbOut)
Jiyong Park09d77522019-11-18 11:16:27 +0900354
355 if a.properties.Whitelisted_files != nil {
356 ctx.Build(pctx, android.BuildParams{
357 Rule: emitApexContentRule,
358 Implicits: implicitInputs,
359 Output: imageContentFile,
360 Description: "emit apex image content",
361 Args: map[string]string{
362 "emit_commands": strings.Join(emitCommands, " && "),
363 },
364 })
365 implicitInputs = append(implicitInputs, imageContentFile)
366 whitelistedFilesFile := android.PathForModuleSrc(ctx, proptools.String(a.properties.Whitelisted_files))
367
Jaewoong Jung1670ca02019-11-22 14:50:42 -0800368 phonyOutput := android.PathForModuleOut(ctx, a.Name()+"-diff-phony-output")
Jiyong Park09d77522019-11-18 11:16:27 +0900369 ctx.Build(pctx, android.BuildParams{
370 Rule: diffApexContentRule,
371 Implicits: implicitInputs,
372 Output: phonyOutput,
373 Description: "diff apex image content",
374 Args: map[string]string{
375 "whitelisted_files_file": whitelistedFilesFile.String(),
376 "image_content_file": imageContentFile.String(),
Jaewoong Jung1670ca02019-11-22 14:50:42 -0800377 "apex_module_name": a.Name(),
Jiyong Park09d77522019-11-18 11:16:27 +0900378 },
379 })
380
381 implicitInputs = append(implicitInputs, phonyOutput)
382 }
383
384 outHostBinDir := android.PathForOutput(ctx, "host", ctx.Config().PrebuiltOS(), "bin").String()
385 prebuiltSdkToolsBinDir := filepath.Join("prebuilts", "sdk", "tools", runtime.GOOS, "bin")
386
Jiyong Park3a1602e2020-01-14 14:39:19 +0900387 imageDir := android.PathForModuleOut(ctx, "image"+suffix)
Jiyong Park09d77522019-11-18 11:16:27 +0900388 if apexType == imageApex {
389 // files and dirs that will be created in APEX
390 var readOnlyPaths = []string{"apex_manifest.json", "apex_manifest.pb"}
391 var executablePaths []string // this also includes dirs
392 for _, f := range a.filesInfo {
393 pathInApex := filepath.Join(f.installDir, f.builtFile.Base())
394 if f.installDir == "bin" || strings.HasPrefix(f.installDir, "bin/") {
395 executablePaths = append(executablePaths, pathInApex)
396 for _, s := range f.symlinks {
397 executablePaths = append(executablePaths, filepath.Join(f.installDir, s))
398 }
399 } else {
400 readOnlyPaths = append(readOnlyPaths, pathInApex)
401 }
402 dir := f.installDir
403 for !android.InList(dir, executablePaths) && dir != "" {
404 executablePaths = append(executablePaths, dir)
405 dir, _ = filepath.Split(dir) // move up to the parent
406 if len(dir) > 0 {
407 // remove trailing slash
408 dir = dir[:len(dir)-1]
409 }
410 }
411 }
412 sort.Strings(readOnlyPaths)
413 sort.Strings(executablePaths)
414 cannedFsConfig := android.PathForModuleOut(ctx, "canned_fs_config")
415 ctx.Build(pctx, android.BuildParams{
416 Rule: generateFsConfig,
417 Output: cannedFsConfig,
418 Description: "generate fs config",
419 Args: map[string]string{
420 "ro_paths": strings.Join(readOnlyPaths, " "),
421 "exec_paths": strings.Join(executablePaths, " "),
422 },
423 })
424
Jiyong Park09d77522019-11-18 11:16:27 +0900425 optFlags := []string{}
426
427 // Additional implicit inputs.
Jooyung Han54aca7b2019-11-20 02:26:02 +0900428 implicitInputs = append(implicitInputs, cannedFsConfig, a.fileContexts, a.private_key_file, a.public_key_file)
Jiyong Park09d77522019-11-18 11:16:27 +0900429 optFlags = append(optFlags, "--pubkey "+a.public_key_file.String())
430
Jooyung Han27151d92019-12-16 17:45:32 +0900431 manifestPackageName := a.getOverrideManifestPackageName(ctx)
432 if manifestPackageName != "" {
Jiyong Park09d77522019-11-18 11:16:27 +0900433 optFlags = append(optFlags, "--override_apk_package_name "+manifestPackageName)
434 }
435
436 if a.properties.AndroidManifest != nil {
437 androidManifestFile := android.PathForModuleSrc(ctx, proptools.String(a.properties.AndroidManifest))
438 implicitInputs = append(implicitInputs, androidManifestFile)
439 optFlags = append(optFlags, "--android_manifest "+androidManifestFile.String())
440 }
441
442 targetSdkVersion := ctx.Config().DefaultAppTargetSdk()
Baligh Uddinf6201372020-01-24 23:15:44 +0000443 minSdkVersion := ctx.Config().DefaultAppTargetSdk()
Nikita Ioffedb10c132020-02-20 00:43:27 +0000444
Jooyung Han23b0adf2020-03-12 18:37:20 +0900445 if a.minSdkVersion(ctx) == android.SdkVersion_Android10 {
446 minSdkVersion = strconv.Itoa(a.minSdkVersion(ctx))
447 targetSdkVersion = strconv.Itoa(a.minSdkVersion(ctx))
Nikita Ioffedb10c132020-02-20 00:43:27 +0000448 }
449
Nikita Ioffe934c4f22020-03-02 16:58:11 +0000450 if java.UseApiFingerprint(ctx) {
451 targetSdkVersion = ctx.Config().PlatformSdkCodename() + fmt.Sprintf(".$$(cat %s)", java.ApiFingerprintPath(ctx).String())
Baligh Uddinf6201372020-01-24 23:15:44 +0000452 implicitInputs = append(implicitInputs, java.ApiFingerprintPath(ctx))
453 }
Nikita Ioffe934c4f22020-03-02 16:58:11 +0000454 if java.UseApiFingerprint(ctx) {
455 minSdkVersion = ctx.Config().PlatformSdkCodename() + fmt.Sprintf(".$$(cat %s)", java.ApiFingerprintPath(ctx).String())
Baligh Uddinf6201372020-01-24 23:15:44 +0000456 implicitInputs = append(implicitInputs, java.ApiFingerprintPath(ctx))
Jiyong Park09d77522019-11-18 11:16:27 +0900457 }
458 optFlags = append(optFlags, "--target_sdk_version "+targetSdkVersion)
Baligh Uddinf6201372020-01-24 23:15:44 +0000459 optFlags = append(optFlags, "--min_sdk_version "+minSdkVersion)
Jiyong Park09d77522019-11-18 11:16:27 +0900460
Baligh Uddin004d7172020-02-19 21:29:28 -0800461 if a.overridableProperties.Logging_parent != "" {
462 optFlags = append(optFlags, "--logging_parent ", a.overridableProperties.Logging_parent)
463 }
464
Jiyong Park19972c72020-01-28 20:05:29 +0900465 a.mergedNotices = a.buildNoticeFiles(ctx, a.Name()+suffix)
466 if a.mergedNotices.HtmlGzOutput.Valid() {
Jiyong Park09d77522019-11-18 11:16:27 +0900467 // If there's a NOTICE file, embed it as an asset file in the APEX.
Jiyong Park19972c72020-01-28 20:05:29 +0900468 implicitInputs = append(implicitInputs, a.mergedNotices.HtmlGzOutput.Path())
469 optFlags = append(optFlags, "--assets_dir "+filepath.Dir(a.mergedNotices.HtmlGzOutput.String()))
Jiyong Park09d77522019-11-18 11:16:27 +0900470 }
471
Nikita Ioffeb4b44c02020-01-02 23:01:39 +0000472 if ctx.ModuleDir() != "system/apex/apexd/apexd_testdata" && ctx.ModuleDir() != "system/apex/shim/build" && a.testOnlyShouldSkipHashtreeGeneration() {
Nikita Ioffec72b5dd2019-12-07 17:30:22 +0000473 ctx.PropertyErrorf("test_only_no_hashtree", "not available")
474 return
475 }
Jooyung Han23b0adf2020-03-12 18:37:20 +0900476 if a.minSdkVersion(ctx) > android.SdkVersion_Android10 || a.testOnlyShouldSkipHashtreeGeneration() {
Jiyong Park09d77522019-11-18 11:16:27 +0900477 // Apexes which are supposed to be installed in builtin dirs(/system, etc)
478 // don't need hashtree for activation. Therefore, by removing hashtree from
479 // apex bundle (filesystem image in it, to be specific), we can save storage.
480 optFlags = append(optFlags, "--no_hashtree")
481 }
482
483 if a.properties.Apex_name != nil {
484 // If apex_name is set, apexer can skip checking if key name matches with apex name.
485 // Note that apex_manifest is also mended.
486 optFlags = append(optFlags, "--do_not_check_keyname")
487 }
488
Jooyung Han23b0adf2020-03-12 18:37:20 +0900489 if a.minSdkVersion(ctx) == android.SdkVersion_Android10 {
Jooyung Han214bf372019-11-12 13:03:50 +0900490 implicitInputs = append(implicitInputs, a.manifestJsonOut)
491 optFlags = append(optFlags, "--manifest_json "+a.manifestJsonOut.String())
492 }
493
Jiyong Park09d77522019-11-18 11:16:27 +0900494 ctx.Build(pctx, android.BuildParams{
495 Rule: apexRule,
496 Implicits: implicitInputs,
497 Output: unsignedOutputFile,
498 Description: "apex (" + apexType.name() + ")",
499 Args: map[string]string{
Jooyung Han214bf372019-11-12 13:03:50 +0900500 "tool_path": outHostBinDir + ":" + prebuiltSdkToolsBinDir,
Jiyong Park3a1602e2020-01-14 14:39:19 +0900501 "image_dir": imageDir.String(),
Jooyung Han214bf372019-11-12 13:03:50 +0900502 "copy_commands": strings.Join(copyCommands, " && "),
503 "manifest": a.manifestPbOut.String(),
504 "file_contexts": a.fileContexts.String(),
505 "canned_fs_config": cannedFsConfig.String(),
506 "key": a.private_key_file.String(),
507 "opt_flags": strings.Join(optFlags, " "),
Jiyong Park09d77522019-11-18 11:16:27 +0900508 },
509 })
510
Jaewoong Jung1670ca02019-11-22 14:50:42 -0800511 apexProtoFile := android.PathForModuleOut(ctx, a.Name()+".pb"+suffix)
512 bundleModuleFile := android.PathForModuleOut(ctx, a.Name()+suffix+"-base.zip")
Jiyong Park09d77522019-11-18 11:16:27 +0900513 a.bundleModuleFile = bundleModuleFile
514
515 ctx.Build(pctx, android.BuildParams{
516 Rule: apexProtoConvertRule,
517 Input: unsignedOutputFile,
518 Output: apexProtoFile,
519 Description: "apex proto convert",
520 })
521
Jiyong Parkd93e1b12020-02-28 15:22:21 +0900522 bundleConfig := a.buildBundleConfig(ctx)
523
Jiyong Park09d77522019-11-18 11:16:27 +0900524 ctx.Build(pctx, android.BuildParams{
525 Rule: apexBundleRule,
526 Input: apexProtoFile,
Jiyong Parkd93e1b12020-02-28 15:22:21 +0900527 Implicit: bundleConfig,
Jiyong Park09d77522019-11-18 11:16:27 +0900528 Output: a.bundleModuleFile,
529 Description: "apex bundle module",
530 Args: map[string]string{
Jiyong Parkd93e1b12020-02-28 15:22:21 +0900531 "abi": strings.Join(abis, "."),
532 "config": bundleConfig.String(),
Jiyong Park09d77522019-11-18 11:16:27 +0900533 },
534 })
535 } else {
536 ctx.Build(pctx, android.BuildParams{
537 Rule: zipApexRule,
538 Implicits: implicitInputs,
539 Output: unsignedOutputFile,
540 Description: "apex (" + apexType.name() + ")",
541 Args: map[string]string{
Jooyung Han214bf372019-11-12 13:03:50 +0900542 "tool_path": outHostBinDir + ":" + prebuiltSdkToolsBinDir,
Jiyong Park3a1602e2020-01-14 14:39:19 +0900543 "image_dir": imageDir.String(),
Jooyung Han214bf372019-11-12 13:03:50 +0900544 "copy_commands": strings.Join(copyCommands, " && "),
545 "manifest": a.manifestPbOut.String(),
Jiyong Park09d77522019-11-18 11:16:27 +0900546 },
547 })
548 }
549
Jaewoong Jung1670ca02019-11-22 14:50:42 -0800550 a.outputFile = android.PathForModuleOut(ctx, a.Name()+suffix)
Jiyong Park09d77522019-11-18 11:16:27 +0900551 ctx.Build(pctx, android.BuildParams{
552 Rule: java.Signapk,
553 Description: "signapk",
554 Output: a.outputFile,
555 Input: unsignedOutputFile,
556 Implicits: []android.Path{
557 a.container_certificate_file,
558 a.container_private_key_file,
559 },
560 Args: map[string]string{
561 "certificates": a.container_certificate_file.String() + " " + a.container_private_key_file.String(),
562 "flags": "-a 4096", //alignment
563 },
564 })
565
566 // Install to $OUT/soong/{target,host}/.../apex
567 if a.installable() {
Jaewoong Jung1670ca02019-11-22 14:50:42 -0800568 ctx.InstallFile(a.installDir, a.Name()+suffix, a.outputFile)
Jiyong Park09d77522019-11-18 11:16:27 +0900569 }
570 a.buildFilesInfo(ctx)
Jiyong Park3a1602e2020-01-14 14:39:19 +0900571
572 // installed-files.txt is dist'ed
573 a.installedFilesFile = a.buildInstalledFilesFile(ctx, a.outputFile, imageDir)
Jiyong Park09d77522019-11-18 11:16:27 +0900574}
575
576func (a *apexBundle) buildFlattenedApex(ctx android.ModuleContext) {
577 // Temporarily wrap the original `ctx` into a `flattenedApexContext` to have it
578 // reply true to `InstallBypassMake()` (thus making the call
579 // `android.PathForModuleInstall` below use `android.pathForInstallInMakeDir`
580 // instead of `android.PathForOutput`) to return the correct path to the flattened
581 // APEX (as its contents is installed by Make, not Soong).
582 factx := flattenedApexContext{ctx}
Jiyong Parka5948012020-02-07 10:15:14 +0900583 apexBundleName := a.Name()
584 a.outputFile = android.PathForModuleInstall(&factx, "apex", apexBundleName)
Jiyong Park09d77522019-11-18 11:16:27 +0900585
Jiyong Park317645e2019-12-05 13:20:58 +0900586 if a.installable() && a.GetOverriddenBy() == "" {
Jiyong Parka5948012020-02-07 10:15:14 +0900587 installPath := android.PathForModuleInstall(ctx, "apex", apexBundleName)
Jooyung Han54aca7b2019-11-20 02:26:02 +0900588 devicePath := android.InstallPathToOnDevicePath(ctx, installPath)
Jiyong Parka5948012020-02-07 10:15:14 +0900589 addFlattenedFileContextsInfos(ctx, apexBundleName+":"+devicePath+":"+a.fileContexts.String())
Jooyung Han54aca7b2019-11-20 02:26:02 +0900590 }
Jiyong Park09d77522019-11-18 11:16:27 +0900591 a.buildFilesInfo(ctx)
592}
593
594func (a *apexBundle) setCertificateAndPrivateKey(ctx android.ModuleContext) {
Jooyung Hanf121a652019-12-17 14:30:11 +0900595 if a.container_certificate_file == nil {
596 cert := String(a.properties.Certificate)
597 if cert == "" {
598 pem, key := ctx.Config().DefaultAppCertificate(ctx)
599 a.container_certificate_file = pem
600 a.container_private_key_file = key
601 } else {
602 defaultDir := ctx.Config().DefaultAppCertificateDir(ctx)
603 a.container_certificate_file = defaultDir.Join(ctx, cert+".x509.pem")
604 a.container_private_key_file = defaultDir.Join(ctx, cert+".pk8")
605 }
Jiyong Park09d77522019-11-18 11:16:27 +0900606 }
607}
608
609func (a *apexBundle) buildFilesInfo(ctx android.ModuleContext) {
610 if a.installable() {
Jooyung Han214bf372019-11-12 13:03:50 +0900611 // For flattened APEX, do nothing but make sure that APEX manifest and apex_pubkey are also copied along
Jiyong Park09d77522019-11-18 11:16:27 +0900612 // with other ordinary files.
Jiyong Park7cd10e32020-01-14 09:22:18 +0900613 a.filesInfo = append(a.filesInfo, newApexFile(ctx, a.manifestPbOut, "apex_manifest.pb", ".", etc, nil))
Jiyong Park09d77522019-11-18 11:16:27 +0900614
615 // rename to apex_pubkey
616 copiedPubkey := android.PathForModuleOut(ctx, "apex_pubkey")
617 ctx.Build(pctx, android.BuildParams{
618 Rule: android.Cp,
619 Input: a.public_key_file,
620 Output: copiedPubkey,
621 })
Jiyong Park7cd10e32020-01-14 09:22:18 +0900622 a.filesInfo = append(a.filesInfo, newApexFile(ctx, copiedPubkey, "apex_pubkey", ".", etc, nil))
Jiyong Park09d77522019-11-18 11:16:27 +0900623
624 if a.properties.ApexType == flattenedApex {
Jiyong Parka5948012020-02-07 10:15:14 +0900625 apexBundleName := a.Name()
Jiyong Park09d77522019-11-18 11:16:27 +0900626 for _, fi := range a.filesInfo {
Jiyong Parka5948012020-02-07 10:15:14 +0900627 dir := filepath.Join("apex", apexBundleName, fi.installDir)
Jiyong Park09d77522019-11-18 11:16:27 +0900628 target := ctx.InstallFile(android.PathForModuleInstall(ctx, dir), fi.builtFile.Base(), fi.builtFile)
629 for _, sym := range fi.symlinks {
630 ctx.InstallSymlink(android.PathForModuleInstall(ctx, dir), sym, target)
631 }
632 }
633 }
634 }
635}
Jooyung Han27151d92019-12-16 17:45:32 +0900636
637func (a *apexBundle) getOverrideManifestPackageName(ctx android.ModuleContext) string {
638 // For VNDK APEXes, check "com.android.vndk" in PRODUCT_MANIFEST_PACKAGE_NAME_OVERRIDES
639 // to see if it should be overridden because their <apex name> is dynamically generated
640 // according to its VNDK version.
641 if a.vndkApex {
642 overrideName, overridden := ctx.DeviceConfig().OverrideManifestPackageNameFor(vndkApexName)
643 if overridden {
644 return strings.Replace(*a.properties.Apex_name, vndkApexName, overrideName, 1)
645 }
646 return ""
647 }
Baligh Uddincb6aa122020-03-15 13:01:05 -0700648 if a.overridableProperties.Package_name != "" {
649 return a.overridableProperties.Package_name
650 }
Jiyong Parka519c542020-03-03 11:45:41 +0900651 manifestPackageName, overridden := ctx.DeviceConfig().OverrideManifestPackageNameFor(ctx.ModuleName())
Jooyung Han27151d92019-12-16 17:45:32 +0900652 if overridden {
653 return manifestPackageName
654 }
655 return ""
656}
Jiyong Park83dc74b2020-01-14 18:38:44 +0900657
658func (a *apexBundle) buildApexDependencyInfo(ctx android.ModuleContext) {
659 if !a.primaryApexType {
660 return
661 }
662
663 if a.properties.IsCoverageVariant {
664 // Otherwise, we will have duplicated rules for coverage and
665 // non-coverage variants of the same APEX
666 return
667 }
668
669 if ctx.Host() {
670 // No need to generate dependency info for host variant
671 return
672 }
673
Jiyong Park83dc74b2020-01-14 18:38:44 +0900674 var content strings.Builder
Jiyong Park678c8812020-02-07 17:25:49 +0900675 for _, key := range android.SortedStringKeys(a.depInfos) {
676 info := a.depInfos[key]
677 toName := info.to
678 if info.isExternal {
679 toName = toName + " (external)"
680 }
681 fmt.Fprintf(&content, "%s <- %s\\n", toName, strings.Join(android.SortedUniqueStrings(info.from), ", "))
Jiyong Park83dc74b2020-01-14 18:38:44 +0900682 }
683
684 depsInfoFile := android.PathForOutput(ctx, a.Name()+"-deps-info.txt")
685 ctx.Build(pctx, android.BuildParams{
686 Rule: android.WriteFile,
687 Description: "Dependency Info",
688 Output: depsInfoFile,
689 Args: map[string]string{
690 "content": content.String(),
691 },
692 })
693
694 ctx.Build(pctx, android.BuildParams{
695 Rule: android.Phony,
696 Output: android.PathForPhony(ctx, a.Name()+"-deps-info"),
697 Inputs: []android.Path{depsInfoFile},
698 })
699}