blob: 4a18dcada18e7b07ee542b8fba90b9bee8a412fe [file] [log] [blame]
// Copyright 2015 Google Inc. All rights reserved.
//
// 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.
package java
// This file generates the final rules for compiling all Java. All properties related to
// compiling should have been translated into javaBuilderFlags or another argument to the Transform*
// functions.
import (
"path/filepath"
"strings"
"github.com/google/blueprint"
"github.com/google/blueprint/proptools"
"android/soong/android"
"android/soong/remoteexec"
)
var (
Signapk, SignapkRE = pctx.RemoteStaticRules("signapk",
blueprint.RuleParams{
Command: `rm -f $out && $reTemplate${config.JavaCmd} ${config.JavaVmFlags} -Djava.library.path=$$(dirname ${config.SignapkJniLibrary}) ` +
`-jar ${config.SignapkCmd} $flags $certificates $in $out`,
CommandDeps: []string{"${config.SignapkCmd}", "${config.SignapkJniLibrary}"},
},
&remoteexec.REParams{Labels: map[string]string{"type": "tool", "name": "signapk"},
ExecStrategy: "${config.RESignApkExecStrategy}",
Inputs: []string{"${config.SignapkCmd}", "$in", "$$(dirname ${config.SignapkJniLibrary})", "$implicits"},
OutputFiles: []string{"$outCommaList"},
ToolchainInputs: []string{"${config.JavaCmd}"},
Platform: map[string]string{remoteexec.PoolKey: "${config.REJavaPool}"},
}, []string{"flags", "certificates"}, []string{"implicits", "outCommaList"})
)
var combineApk = pctx.AndroidStaticRule("combineApk",
blueprint.RuleParams{
Command: `${config.MergeZipsCmd} $out $in`,
CommandDeps: []string{"${config.MergeZipsCmd}"},
})
func CreateAndSignAppPackage(ctx android.ModuleContext, outputFile android.WritablePath,
packageFile, jniJarFile, dexJarFile android.Path, certificates []Certificate, deps android.Paths, v4SignatureFile android.WritablePath, lineageFile android.Path) {
unsignedApkName := strings.TrimSuffix(outputFile.Base(), ".apk") + "-unsigned.apk"
unsignedApk := android.PathForModuleOut(ctx, unsignedApkName)
var inputs android.Paths
if dexJarFile != nil {
inputs = append(inputs, dexJarFile)
}
inputs = append(inputs, packageFile)
if jniJarFile != nil {
inputs = append(inputs, jniJarFile)
}
ctx.Build(pctx, android.BuildParams{
Rule: combineApk,
Inputs: inputs,
Output: unsignedApk,
Implicits: deps,
})
SignAppPackage(ctx, outputFile, unsignedApk, certificates, v4SignatureFile, lineageFile)
}
func SignAppPackage(ctx android.ModuleContext, signedApk android.WritablePath, unsignedApk android.Path, certificates []Certificate, v4SignatureFile android.WritablePath, lineageFile android.Path) {
var certificateArgs []string
var deps android.Paths
for _, c := range certificates {
certificateArgs = append(certificateArgs, c.Pem.String(), c.Key.String())
deps = append(deps, c.Pem, c.Key)
}
outputFiles := android.WritablePaths{signedApk}
var flags []string
if v4SignatureFile != nil {
outputFiles = append(outputFiles, v4SignatureFile)
flags = append(flags, "--enable-v4")
}
if lineageFile != nil {
flags = append(flags, "--lineage", lineageFile.String())
deps = append(deps, lineageFile)
}
rule := Signapk
args := map[string]string{
"certificates": strings.Join(certificateArgs, " "),
"flags": strings.Join(flags, " "),
}
if ctx.Config().UseRBE() && ctx.Config().IsEnvTrue("RBE_SIGNAPK") {
rule = SignapkRE
args["implicits"] = strings.Join(deps.Strings(), ",")
args["outCommaList"] = strings.Join(outputFiles.Strings(), ",")
}
ctx.Build(pctx, android.BuildParams{
Rule: rule,
Description: "signapk",
Outputs: outputFiles,
Input: unsignedApk,
Implicits: deps,
Args: args,
})
}
var buildAAR = pctx.AndroidStaticRule("buildAAR",
blueprint.RuleParams{
Command: `rm -rf ${outDir} && mkdir -p ${outDir} && ` +
`cp ${manifest} ${outDir}/AndroidManifest.xml && ` +
`cp ${classesJar} ${outDir}/classes.jar && ` +
`cp ${rTxt} ${outDir}/R.txt && ` +
`${config.SoongZipCmd} -jar -o $out -C ${outDir} -D ${outDir}`,
CommandDeps: []string{"${config.SoongZipCmd}"},
},
"manifest", "classesJar", "rTxt", "outDir")
func BuildAAR(ctx android.ModuleContext, outputFile android.WritablePath,
classesJar, manifest, rTxt android.Path, res android.Paths) {
// TODO(ccross): uniquify and copy resources with dependencies
deps := android.Paths{manifest, rTxt}
classesJarPath := ""
if classesJar != nil {
deps = append(deps, classesJar)
classesJarPath = classesJar.String()
}
ctx.Build(pctx, android.BuildParams{
Rule: buildAAR,
Description: "aar",
Implicits: deps,
Output: outputFile,
Args: map[string]string{
"manifest": manifest.String(),
"classesJar": classesJarPath,
"rTxt": rTxt.String(),
"outDir": android.PathForModuleOut(ctx, "aar").String(),
},
})
}
var buildBundleModule = pctx.AndroidStaticRule("buildBundleModule",
blueprint.RuleParams{
Command: `${config.MergeZipsCmd} ${out} ${in}`,
CommandDeps: []string{"${config.MergeZipsCmd}"},
})
var bundleMungePackage = pctx.AndroidStaticRule("bundleMungePackage",
blueprint.RuleParams{
Command: `${config.Zip2ZipCmd} -i ${in} -o ${out} AndroidManifest.xml:manifest/AndroidManifest.xml resources.pb "res/**/*" "assets/**/*"`,
CommandDeps: []string{"${config.Zip2ZipCmd}"},
})
var bundleMungeDexJar = pctx.AndroidStaticRule("bundleMungeDexJar",
blueprint.RuleParams{
Command: `${config.Zip2ZipCmd} -i ${in} -o ${out} "classes*.dex:dex/" && ` +
`${config.Zip2ZipCmd} -i ${in} -o ${resJar} -x "classes*.dex" "**/*:root/"`,
CommandDeps: []string{"${config.Zip2ZipCmd}"},
}, "resJar")
// Builds an app into a module suitable for input to bundletool
func BuildBundleModule(ctx android.ModuleContext, outputFile android.WritablePath,
packageFile, jniJarFile, dexJarFile android.Path) {
protoResJarFile := android.PathForModuleOut(ctx, "package-res.pb.apk")
aapt2Convert(ctx, protoResJarFile, packageFile)
var zips android.Paths
mungedPackage := android.PathForModuleOut(ctx, "bundle", "apk.zip")
ctx.Build(pctx, android.BuildParams{
Rule: bundleMungePackage,
Input: protoResJarFile,
Output: mungedPackage,
Description: "bundle apk",
})
zips = append(zips, mungedPackage)
if dexJarFile != nil {
mungedDexJar := android.PathForModuleOut(ctx, "bundle", "dex.zip")
mungedResJar := android.PathForModuleOut(ctx, "bundle", "res.zip")
ctx.Build(pctx, android.BuildParams{
Rule: bundleMungeDexJar,
Input: dexJarFile,
Output: mungedDexJar,
ImplicitOutput: mungedResJar,
Description: "bundle dex",
Args: map[string]string{
"resJar": mungedResJar.String(),
},
})
zips = append(zips, mungedDexJar, mungedResJar)
}
if jniJarFile != nil {
zips = append(zips, jniJarFile)
}
ctx.Build(pctx, android.BuildParams{
Rule: buildBundleModule,
Inputs: zips,
Output: outputFile,
Description: "bundle",
})
}
func TransformJniLibsToJar(ctx android.ModuleContext, outputFile android.WritablePath,
jniLibs []jniLib, uncompressJNI bool) {
var deps android.Paths
jarArgs := []string{
"-j", // junk paths, they will be added back with -P arguments
}
if uncompressJNI {
jarArgs = append(jarArgs, "-L", "0")
}
for _, j := range jniLibs {
deps = append(deps, j.path)
jarArgs = append(jarArgs,
"-P", targetToJniDir(j.target),
"-f", j.path.String())
}
rule := zip
args := map[string]string{
"jarArgs": strings.Join(proptools.NinjaAndShellEscapeList(jarArgs), " "),
}
if ctx.Config().UseRBE() && ctx.Config().IsEnvTrue("RBE_ZIP") {
rule = zipRE
args["implicits"] = strings.Join(deps.Strings(), ",")
}
ctx.Build(pctx, android.BuildParams{
Rule: rule,
Description: "zip jni libs",
Output: outputFile,
Implicits: deps,
Args: args,
})
}
func targetToJniDir(target android.Target) string {
return filepath.Join("lib", target.Arch.Abi[0])
}