1269a74fad
The only difference between preprocessed + presigned vs just presigned is that just presigned will zip align the apk, and preprocessed + presigned will instead check that the apk is already aligned and has uncompressed jni and dex libs. This should be the default to ensure we're getting valid apk imports from external sources. Presigned alone also won't work for apps with target sdk >= 30, because on those target sdks you have to use apk signature v2, and having the build system align the zip file will break that signature. Bug: 185811447 Test: Presubmits Change-Id: Ie825ab2eab4feeda5c266233a9dca7bbf9559be7
1043 lines
27 KiB
Go
1043 lines
27 KiB
Go
// Copyright 2017 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 main
|
|
|
|
import (
|
|
"archive/zip"
|
|
"bufio"
|
|
"bytes"
|
|
"encoding/xml"
|
|
"flag"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"os"
|
|
"os/exec"
|
|
"path"
|
|
"path/filepath"
|
|
"regexp"
|
|
"sort"
|
|
"strings"
|
|
"text/template"
|
|
|
|
"github.com/google/blueprint/proptools"
|
|
|
|
"android/soong/bpfix/bpfix"
|
|
)
|
|
|
|
type RewriteNames []RewriteName
|
|
type RewriteName struct {
|
|
regexp *regexp.Regexp
|
|
repl string
|
|
}
|
|
|
|
func (r *RewriteNames) String() string {
|
|
return ""
|
|
}
|
|
|
|
func (r *RewriteNames) Set(v string) error {
|
|
split := strings.SplitN(v, "=", 2)
|
|
if len(split) != 2 {
|
|
return fmt.Errorf("Must be in the form of <regex>=<replace>")
|
|
}
|
|
regex, err := regexp.Compile(split[0])
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
*r = append(*r, RewriteName{
|
|
regexp: regex,
|
|
repl: split[1],
|
|
})
|
|
return nil
|
|
}
|
|
|
|
func (r *RewriteNames) MavenToBp(groupId string, artifactId string) string {
|
|
for _, r := range *r {
|
|
if r.regexp.MatchString(groupId + ":" + artifactId) {
|
|
return r.regexp.ReplaceAllString(groupId+":"+artifactId, r.repl)
|
|
} else if r.regexp.MatchString(artifactId) {
|
|
return r.regexp.ReplaceAllString(artifactId, r.repl)
|
|
}
|
|
}
|
|
return artifactId
|
|
}
|
|
|
|
var rewriteNames = RewriteNames{}
|
|
|
|
type ExtraDeps map[string][]string
|
|
|
|
func (d ExtraDeps) String() string {
|
|
return ""
|
|
}
|
|
|
|
func (d ExtraDeps) Set(v string) error {
|
|
split := strings.SplitN(v, "=", 2)
|
|
if len(split) != 2 {
|
|
return fmt.Errorf("Must be in the form of <module>=<module>[,<module>]")
|
|
}
|
|
d[split[0]] = strings.Split(split[1], ",")
|
|
return nil
|
|
}
|
|
|
|
var extraStaticLibs = make(ExtraDeps)
|
|
|
|
var extraLibs = make(ExtraDeps)
|
|
|
|
var optionalUsesLibs = make(ExtraDeps)
|
|
|
|
type Exclude map[string]bool
|
|
|
|
func (e Exclude) String() string {
|
|
return ""
|
|
}
|
|
|
|
func (e Exclude) Set(v string) error {
|
|
e[v] = true
|
|
return nil
|
|
}
|
|
|
|
var excludes = make(Exclude)
|
|
|
|
type HostModuleNames map[string]bool
|
|
|
|
func (n HostModuleNames) IsHostModule(groupId string, artifactId string) bool {
|
|
_, found := n[groupId+":"+artifactId]
|
|
return found
|
|
}
|
|
|
|
func (n HostModuleNames) String() string {
|
|
return ""
|
|
}
|
|
|
|
func (n HostModuleNames) Set(v string) error {
|
|
n[v] = true
|
|
return nil
|
|
}
|
|
|
|
var hostModuleNames = HostModuleNames{}
|
|
|
|
type HostAndDeviceModuleNames map[string]bool
|
|
|
|
func (n HostAndDeviceModuleNames) IsHostAndDeviceModule(groupId string, artifactId string) bool {
|
|
_, found := n[groupId+":"+artifactId]
|
|
|
|
return found
|
|
}
|
|
|
|
func (n HostAndDeviceModuleNames) String() string {
|
|
return ""
|
|
}
|
|
|
|
func (n HostAndDeviceModuleNames) Set(v string) error {
|
|
n[v] = true
|
|
return nil
|
|
}
|
|
|
|
var hostAndDeviceModuleNames = HostAndDeviceModuleNames{}
|
|
|
|
var sdkVersion string
|
|
var defaultMinSdkVersion string
|
|
var useVersion string
|
|
var staticDeps bool
|
|
var writeCmd bool
|
|
var jetifier bool
|
|
|
|
func InList(s string, list []string) bool {
|
|
for _, l := range list {
|
|
if l == s {
|
|
return true
|
|
}
|
|
}
|
|
|
|
return false
|
|
}
|
|
|
|
type Dependency struct {
|
|
XMLName xml.Name `xml:"dependency"`
|
|
|
|
BpTarget string `xml:"-"`
|
|
BazelTarget string `xml:"-"`
|
|
|
|
GroupId string `xml:"groupId"`
|
|
ArtifactId string `xml:"artifactId"`
|
|
Version string `xml:"version"`
|
|
Type string `xml:"type"`
|
|
Scope string `xml:"scope"`
|
|
}
|
|
|
|
func (d Dependency) BpName() string {
|
|
if d.BpTarget == "" {
|
|
d.BpTarget = rewriteNames.MavenToBp(d.GroupId, d.ArtifactId)
|
|
}
|
|
return d.BpTarget
|
|
}
|
|
|
|
type Pom struct {
|
|
XMLName xml.Name `xml:"http://maven.apache.org/POM/4.0.0 project"`
|
|
|
|
PomFile string `xml:"-"`
|
|
ArtifactFile string `xml:"-"`
|
|
BpTarget string `xml:"-"`
|
|
MinSdkVersion string `xml:"-"`
|
|
|
|
GroupId string `xml:"groupId"`
|
|
ArtifactId string `xml:"artifactId"`
|
|
Version string `xml:"version"`
|
|
Packaging string `xml:"packaging"`
|
|
|
|
Dependencies []*Dependency `xml:"dependencies>dependency"`
|
|
}
|
|
|
|
func (p Pom) IsAar() bool {
|
|
return p.Packaging == "aar"
|
|
}
|
|
|
|
func (p Pom) IsJar() bool {
|
|
return p.Packaging == "jar"
|
|
}
|
|
|
|
func (p Pom) IsApk() bool {
|
|
return p.Packaging == "apk"
|
|
}
|
|
|
|
func (p Pom) IsHostModule() bool {
|
|
return hostModuleNames.IsHostModule(p.GroupId, p.ArtifactId)
|
|
}
|
|
|
|
func (p Pom) IsDeviceModule() bool {
|
|
return !p.IsHostModule()
|
|
}
|
|
|
|
func (p Pom) IsHostAndDeviceModule() bool {
|
|
return hostAndDeviceModuleNames.IsHostAndDeviceModule(p.GroupId, p.ArtifactId)
|
|
}
|
|
|
|
func (p Pom) IsHostOnly() bool {
|
|
return p.IsHostModule() && !p.IsHostAndDeviceModule()
|
|
}
|
|
|
|
func (p Pom) ModuleType() string {
|
|
if p.IsAar() {
|
|
return "android_library"
|
|
} else if p.IsHostOnly() {
|
|
return "java_library_host"
|
|
} else {
|
|
return "java_library_static"
|
|
}
|
|
}
|
|
|
|
func (p Pom) BazelTargetType() string {
|
|
if p.IsAar() {
|
|
return "android_library"
|
|
} else {
|
|
return "java_library"
|
|
}
|
|
}
|
|
|
|
func (p Pom) ImportModuleType() string {
|
|
if p.IsAar() {
|
|
return "android_library_import"
|
|
} else if p.IsApk() {
|
|
return "android_app_import"
|
|
} else if p.IsHostOnly() {
|
|
return "java_import_host"
|
|
} else {
|
|
return "java_import"
|
|
}
|
|
}
|
|
|
|
func (p Pom) BazelImportTargetType() string {
|
|
if p.IsAar() {
|
|
return "aar_import"
|
|
} else if p.IsApk() {
|
|
return "apk_import"
|
|
} else {
|
|
return "java_import"
|
|
}
|
|
}
|
|
|
|
func (p Pom) ImportProperty() string {
|
|
if p.IsAar() {
|
|
return "aars"
|
|
} else if p.IsApk() {
|
|
return "apk"
|
|
} else {
|
|
return "jars"
|
|
}
|
|
}
|
|
|
|
func (p Pom) BazelImportProperty() string {
|
|
if p.IsAar() {
|
|
return "aar"
|
|
} else if p.IsApk() {
|
|
return "apk"
|
|
} else {
|
|
return "jars"
|
|
}
|
|
}
|
|
|
|
func (p Pom) BpName() string {
|
|
if p.BpTarget == "" {
|
|
p.BpTarget = rewriteNames.MavenToBp(p.GroupId, p.ArtifactId)
|
|
}
|
|
return p.BpTarget
|
|
}
|
|
|
|
func (p Pom) BpJarDeps() []string {
|
|
return p.BpDeps("jar", []string{"compile", "runtime"})
|
|
}
|
|
|
|
func (p Pom) BpAarDeps() []string {
|
|
return p.BpDeps("aar", []string{"compile", "runtime"})
|
|
}
|
|
|
|
func (p Pom) BazelJarDeps() []string {
|
|
return p.BazelDeps("jar", []string{"compile", "runtime"})
|
|
}
|
|
|
|
func (p Pom) BazelAarDeps() []string {
|
|
return p.BazelDeps("aar", []string{"compile", "runtime"})
|
|
}
|
|
|
|
func (p Pom) BpExtraStaticLibs() []string {
|
|
return extraStaticLibs[p.BpName()]
|
|
}
|
|
|
|
func (p Pom) BpExtraLibs() []string {
|
|
return extraLibs[p.BpName()]
|
|
}
|
|
|
|
func (p Pom) BpOptionalUsesLibs() []string {
|
|
return optionalUsesLibs[p.BpName()]
|
|
}
|
|
|
|
// BpDeps obtains dependencies filtered by type and scope. The results of this
|
|
// method are formatted as Android.bp targets, e.g. run through MavenToBp rules.
|
|
func (p Pom) BpDeps(typeExt string, scopes []string) []string {
|
|
var ret []string
|
|
for _, d := range p.Dependencies {
|
|
if d.Type != typeExt || !InList(d.Scope, scopes) {
|
|
continue
|
|
}
|
|
name := rewriteNames.MavenToBp(d.GroupId, d.ArtifactId)
|
|
ret = append(ret, name)
|
|
}
|
|
return ret
|
|
}
|
|
|
|
// BazelDeps obtains dependencies filtered by type and scope. The results of this
|
|
// method are formatted as Bazel BUILD targets.
|
|
func (p Pom) BazelDeps(typeExt string, scopes []string) []string {
|
|
var ret []string
|
|
for _, d := range p.Dependencies {
|
|
if d.Type != typeExt || !InList(d.Scope, scopes) {
|
|
continue
|
|
}
|
|
ret = append(ret, d.BazelTarget)
|
|
}
|
|
return ret
|
|
}
|
|
|
|
func PathModVars() (string, string, string) {
|
|
cmd := "/bin/bash"
|
|
androidTop := os.Getenv("ANDROID_BUILD_TOP")
|
|
envSetupSh := path.Join(androidTop, "build/envsetup.sh")
|
|
return cmd, androidTop, envSetupSh
|
|
}
|
|
|
|
func InitRefreshMod(poms []*Pom) error {
|
|
cmd, _, envSetupSh := PathModVars()
|
|
// refreshmod is expensive, so if pathmod is already working we can skip it.
|
|
_, err := exec.Command(cmd, "-c", ". "+envSetupSh+" && pathmod "+poms[0].BpName()).Output()
|
|
if exitErr, _ := err.(*exec.ExitError); exitErr != nil || err != nil {
|
|
_, err := exec.Command(cmd, "-c", ". "+envSetupSh+" && refreshmod").Output()
|
|
if exitErr, _ := err.(*exec.ExitError); exitErr != nil {
|
|
return fmt.Errorf("failed to run %s\n%s\ntry running lunch.", cmd, string(exitErr.Stderr))
|
|
} else if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func BazelifyExtraDeps(extraDeps ExtraDeps, modules map[string]*Pom) error {
|
|
for _, deps := range extraDeps {
|
|
for _, dep := range deps {
|
|
bazelName, err := BpNameToBazelTarget(dep, modules)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
dep = bazelName
|
|
}
|
|
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (p *Pom) GetBazelDepNames(modules map[string]*Pom) error {
|
|
for _, d := range p.Dependencies {
|
|
bazelName, err := BpNameToBazelTarget(d.BpName(), modules)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
d.BazelTarget = bazelName
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func BpNameToBazelTarget(bpName string, modules map[string]*Pom) (string, error) {
|
|
cmd, androidTop, envSetupSh := PathModVars()
|
|
|
|
if _, ok := modules[bpName]; ok {
|
|
// We've seen the POM for this dependency, it will be local to the output BUILD file
|
|
return ":" + bpName, nil
|
|
} else {
|
|
// we don't have the POM for this artifact, find and use the fully qualified target name.
|
|
output, err := exec.Command(cmd, "-c", ". "+envSetupSh+" && pathmod "+bpName).Output()
|
|
if exitErr, _ := err.(*exec.ExitError); exitErr != nil {
|
|
return "", fmt.Errorf("failed to run %s %s\n%s", cmd, bpName, string(exitErr.Stderr))
|
|
} else if err != nil {
|
|
return "", err
|
|
}
|
|
relPath := ""
|
|
for _, line := range strings.Fields(string(output)) {
|
|
if strings.Contains(line, androidTop) {
|
|
relPath = strings.TrimPrefix(line, androidTop)
|
|
relPath = strings.TrimLeft(relPath, "/")
|
|
}
|
|
}
|
|
return "//" + relPath + ":" + bpName, nil
|
|
}
|
|
}
|
|
|
|
func (p Pom) SdkVersion() string {
|
|
return sdkVersion
|
|
}
|
|
|
|
func (p Pom) DefaultMinSdkVersion() string {
|
|
return defaultMinSdkVersion
|
|
}
|
|
|
|
func (p Pom) Jetifier() bool {
|
|
return jetifier
|
|
}
|
|
|
|
func (p *Pom) FixDeps(modules map[string]*Pom) {
|
|
for _, d := range p.Dependencies {
|
|
if d.Type == "" {
|
|
if depPom, ok := modules[d.BpName()]; ok {
|
|
// We've seen the POM for this dependency, use its packaging
|
|
// as the dependency type rather than Maven spec default.
|
|
d.Type = depPom.Packaging
|
|
} else {
|
|
// Dependency type was not specified and we don't have the POM
|
|
// for this artifact, use the default from Maven spec.
|
|
d.Type = "jar"
|
|
}
|
|
}
|
|
if d.Scope == "" {
|
|
// Scope was not specified, use the default from Maven spec.
|
|
d.Scope = "compile"
|
|
}
|
|
}
|
|
}
|
|
|
|
// ExtractMinSdkVersion extracts the minSdkVersion from the AndroidManifest.xml file inside an aar file, or sets it
|
|
// to "current" if it is not present.
|
|
func (p *Pom) ExtractMinSdkVersion() error {
|
|
aar, err := zip.OpenReader(p.ArtifactFile)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer aar.Close()
|
|
|
|
var manifest *zip.File
|
|
for _, f := range aar.File {
|
|
if f.Name == "AndroidManifest.xml" {
|
|
manifest = f
|
|
break
|
|
}
|
|
}
|
|
|
|
if manifest == nil {
|
|
return fmt.Errorf("failed to find AndroidManifest.xml in %s", p.ArtifactFile)
|
|
}
|
|
|
|
r, err := manifest.Open()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer r.Close()
|
|
|
|
decoder := xml.NewDecoder(r)
|
|
|
|
manifestData := struct {
|
|
XMLName xml.Name `xml:"manifest"`
|
|
Uses_sdk struct {
|
|
MinSdkVersion string `xml:"http://schemas.android.com/apk/res/android minSdkVersion,attr"`
|
|
} `xml:"uses-sdk"`
|
|
}{}
|
|
|
|
err = decoder.Decode(&manifestData)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
p.MinSdkVersion = manifestData.Uses_sdk.MinSdkVersion
|
|
if p.MinSdkVersion == "" {
|
|
p.MinSdkVersion = "current"
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
var bpTemplate = template.Must(template.New("bp").Parse(`
|
|
{{.ImportModuleType}} {
|
|
name: "{{.BpName}}",
|
|
{{- if .IsApk}}
|
|
{{.ImportProperty}}: "{{.ArtifactFile}}",
|
|
{{- else}}
|
|
{{.ImportProperty}}: ["{{.ArtifactFile}}"],
|
|
sdk_version: "{{.SdkVersion}}",
|
|
{{- end}}
|
|
{{- if .Jetifier}}
|
|
jetifier: true,
|
|
{{- end}}
|
|
{{- if .IsHostAndDeviceModule}}
|
|
host_supported: true,
|
|
{{- end}}
|
|
{{- if not .IsHostOnly}}
|
|
apex_available: [
|
|
"//apex_available:platform",
|
|
"//apex_available:anyapex",
|
|
],
|
|
{{- end}}
|
|
{{- if .IsAar}}
|
|
min_sdk_version: "{{.MinSdkVersion}}",
|
|
static_libs: [
|
|
{{- range .BpJarDeps}}
|
|
"{{.}}",
|
|
{{- end}}
|
|
{{- range .BpAarDeps}}
|
|
"{{.}}",
|
|
{{- end}}
|
|
{{- range .BpExtraStaticLibs}}
|
|
"{{.}}",
|
|
{{- end}}
|
|
],
|
|
{{- if .BpExtraLibs}}
|
|
libs: [
|
|
{{- range .BpExtraLibs}}
|
|
"{{.}}",
|
|
{{- end}}
|
|
],
|
|
{{- end}}
|
|
{{- if .BpOptionalUsesLibs}}
|
|
optional_uses_libs: [
|
|
{{- range .BpOptionalUsesLibs}}
|
|
"{{.}}",
|
|
{{- end}}
|
|
],
|
|
{{- end}}
|
|
{{- else if not .IsHostOnly}}
|
|
{{- if not .IsApk}}
|
|
min_sdk_version: "{{.DefaultMinSdkVersion}}",
|
|
{{- end}}
|
|
{{- end}}
|
|
{{- if .IsApk}}
|
|
preprocessed: true,
|
|
presigned: true,
|
|
{{- end}}
|
|
|
|
}
|
|
`))
|
|
|
|
var bpDepsTemplate = template.Must(template.New("bp").Parse(`
|
|
{{.ImportModuleType}} {
|
|
name: "{{.BpName}}-nodeps",
|
|
{{.ImportProperty}}: ["{{.ArtifactFile}}"],
|
|
sdk_version: "{{.SdkVersion}}",
|
|
{{- if .Jetifier}}
|
|
jetifier: true,
|
|
{{- end}}
|
|
{{- if .IsHostAndDeviceModule}}
|
|
host_supported: true,
|
|
{{- end}}
|
|
{{- if not .IsHostOnly}}
|
|
apex_available: [
|
|
"//apex_available:platform",
|
|
"//apex_available:anyapex",
|
|
],
|
|
{{- end}}
|
|
{{- if .IsAar}}
|
|
min_sdk_version: "{{.MinSdkVersion}}",
|
|
static_libs: [
|
|
{{- range .BpJarDeps}}
|
|
"{{.}}",
|
|
{{- end}}
|
|
{{- range .BpAarDeps}}
|
|
"{{.}}",
|
|
{{- end}}
|
|
{{- range .BpExtraStaticLibs}}
|
|
"{{.}}",
|
|
{{- end}}
|
|
],
|
|
{{- if .BpExtraLibs}}
|
|
libs: [
|
|
{{- range .BpExtraLibs}}
|
|
"{{.}}",
|
|
{{- end}}
|
|
],
|
|
{{- end}}
|
|
{{- else if not .IsHostOnly}}
|
|
min_sdk_version: "{{.DefaultMinSdkVersion}}",
|
|
{{- end}}
|
|
}
|
|
|
|
{{.ModuleType}} {
|
|
name: "{{.BpName}}",
|
|
{{- if .IsDeviceModule}}
|
|
sdk_version: "{{.SdkVersion}}",
|
|
{{- if .IsHostAndDeviceModule}}
|
|
host_supported: true,
|
|
{{- end}}
|
|
{{- if not .IsHostOnly}}
|
|
apex_available: [
|
|
"//apex_available:platform",
|
|
"//apex_available:anyapex",
|
|
],
|
|
{{- end}}
|
|
{{- if .IsAar}}
|
|
min_sdk_version: "{{.MinSdkVersion}}",
|
|
manifest: "manifests/{{.BpName}}/AndroidManifest.xml",
|
|
{{- else if not .IsHostOnly}}
|
|
min_sdk_version: "{{.DefaultMinSdkVersion}}",
|
|
{{- end}}
|
|
{{- end}}
|
|
static_libs: [
|
|
"{{.BpName}}-nodeps",
|
|
{{- range .BpJarDeps}}
|
|
"{{.}}",
|
|
{{- end}}
|
|
{{- range .BpAarDeps}}
|
|
"{{.}}",
|
|
{{- end}}
|
|
{{- range .BpExtraStaticLibs}}
|
|
"{{.}}",
|
|
{{- end}}
|
|
],
|
|
{{- if .BpExtraLibs}}
|
|
libs: [
|
|
{{- range .BpExtraLibs}}
|
|
"{{.}}",
|
|
{{- end}}
|
|
],
|
|
{{- end}}
|
|
{{- if .BpOptionalUsesLibs}}
|
|
optional_uses_libs: [
|
|
{{- range .BpOptionalUsesLibs}}
|
|
"{{.}}",
|
|
{{- end}}
|
|
],
|
|
{{- end}}
|
|
java_version: "1.7",
|
|
}
|
|
`))
|
|
|
|
var bazelTemplate = template.Must(template.New("bp").Parse(`
|
|
{{.BazelImportTargetType}} (
|
|
name = "{{.BpName}}",
|
|
{{.BazelImportProperty}}: {{- if not .IsAar}}[{{- end}}"{{.ArtifactFile}}"{{- if not .IsAar}}]{{- end}},
|
|
visibility = ["//visibility:public"],
|
|
{{- if .IsAar}}
|
|
deps = [
|
|
{{- range .BazelJarDeps}}
|
|
"{{.}}",
|
|
{{- end}}
|
|
{{- range .BazelAarDeps}}
|
|
"{{.}}",
|
|
{{- end}}
|
|
{{- range .BpExtraStaticLibs}}
|
|
"{{.}}",
|
|
{{- end}}
|
|
{{- range .BpExtraLibs}}
|
|
"{{.}}",
|
|
{{- end}}
|
|
{{- range .BpOptionalUsesLibs}}
|
|
"{{.}}",
|
|
{{- end}}
|
|
],
|
|
{{- end}}
|
|
)
|
|
`))
|
|
|
|
var bazelDepsTemplate = template.Must(template.New("bp").Parse(`
|
|
{{.BazelImportTargetType}} (
|
|
name = "{{.BpName}}",
|
|
{{.BazelImportProperty}} = {{- if not .IsAar}}[{{- end}}"{{.ArtifactFile}}"{{- if not .IsAar}}]{{- end}},
|
|
visibility = ["//visibility:public"],
|
|
exports = [
|
|
{{- range .BazelJarDeps}}
|
|
"{{.}}",
|
|
{{- end}}
|
|
{{- range .BazelAarDeps}}
|
|
"{{.}}",
|
|
{{- end}}
|
|
{{- range .BpExtraStaticLibs}}
|
|
"{{.}}",
|
|
{{- end}}
|
|
{{- range .BpExtraLibs}}
|
|
"{{.}}",
|
|
{{- end}}
|
|
{{- range .BpOptionalUsesLibs}}
|
|
"{{.}}",
|
|
{{- end}}
|
|
],
|
|
)
|
|
`))
|
|
|
|
func parse(filename string) (*Pom, error) {
|
|
data, err := ioutil.ReadFile(filename)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var pom Pom
|
|
err = xml.Unmarshal(data, &pom)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if useVersion != "" && pom.Version != useVersion {
|
|
return nil, nil
|
|
}
|
|
|
|
if pom.Packaging == "" {
|
|
pom.Packaging = "jar"
|
|
}
|
|
|
|
pom.PomFile = filename
|
|
pom.ArtifactFile = strings.TrimSuffix(filename, ".pom") + "." + pom.Packaging
|
|
|
|
return &pom, nil
|
|
}
|
|
|
|
func rerunForRegen(filename string) error {
|
|
buf, err := ioutil.ReadFile(filename)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
scanner := bufio.NewScanner(bytes.NewBuffer(buf))
|
|
|
|
// Skip the first line in the file
|
|
for i := 0; i < 2; i++ {
|
|
if !scanner.Scan() {
|
|
if scanner.Err() != nil {
|
|
return scanner.Err()
|
|
} else {
|
|
return fmt.Errorf("unexpected EOF")
|
|
}
|
|
}
|
|
}
|
|
|
|
// Extract the old args from the file
|
|
line := scanner.Text()
|
|
if strings.HasPrefix(line, "// pom2bp ") { // .bp file
|
|
line = strings.TrimPrefix(line, "// pom2bp ")
|
|
} else if strings.HasPrefix(line, "// pom2mk ") { // .bp file converted from .mk file
|
|
line = strings.TrimPrefix(line, "// pom2mk ")
|
|
} else if strings.HasPrefix(line, "# pom2mk ") { // .mk file
|
|
line = strings.TrimPrefix(line, "# pom2mk ")
|
|
} else if strings.HasPrefix(line, "# pom2bp ") { // Bazel BUILD file
|
|
line = strings.TrimPrefix(line, "# pom2bp ")
|
|
} else {
|
|
return fmt.Errorf("unexpected second line: %q", line)
|
|
}
|
|
args := strings.Split(line, " ")
|
|
lastArg := args[len(args)-1]
|
|
args = args[:len(args)-1]
|
|
|
|
// Append all current command line args except -regen <file> to the ones from the file
|
|
for i := 1; i < len(os.Args); i++ {
|
|
if os.Args[i] == "-regen" || os.Args[i] == "--regen" {
|
|
i++
|
|
} else {
|
|
args = append(args, os.Args[i])
|
|
}
|
|
}
|
|
args = append(args, lastArg)
|
|
|
|
cmd := os.Args[0] + " " + strings.Join(args, " ")
|
|
// Re-exec pom2bp with the new arguments
|
|
output, err := exec.Command("/bin/sh", "-c", cmd).Output()
|
|
if exitErr, _ := err.(*exec.ExitError); exitErr != nil {
|
|
return fmt.Errorf("failed to run %s\n%s", cmd, string(exitErr.Stderr))
|
|
} else if err != nil {
|
|
return err
|
|
}
|
|
|
|
// If the old file was a .mk file, replace it with a .bp file
|
|
if filepath.Ext(filename) == ".mk" {
|
|
os.Remove(filename)
|
|
filename = strings.TrimSuffix(filename, ".mk") + ".bp"
|
|
}
|
|
|
|
return ioutil.WriteFile(filename, output, 0666)
|
|
}
|
|
|
|
func main() {
|
|
flag.Usage = func() {
|
|
fmt.Fprintf(os.Stderr, `pom2bp, a tool to create Android.bp files from maven repos
|
|
|
|
The tool will extract the necessary information from *.pom files to create an Android.bp whose
|
|
aar libraries can be linked against when using AAPT2.
|
|
|
|
Usage: %s [--rewrite <regex>=<replace>] [--exclude <module>] [--extra-static-libs <module>=<module>[,<module>]] [--extra-libs <module>=<module>[,<module>]] [--optional-uses-libs <module>=<module>[,<module>]] [<dir>] [-regen <file>]
|
|
|
|
-rewrite <regex>=<replace>
|
|
rewrite can be used to specify mappings between Maven projects and Android.bp modules. The -rewrite
|
|
option can be specified multiple times. When determining the Android.bp module for a given Maven
|
|
project, mappings are searched in the order they were specified. The first <regex> matching
|
|
either the Maven project's <groupId>:<artifactId> or <artifactId> will be used to generate
|
|
the Android.bp module name using <replace>. If no matches are found, <artifactId> is used.
|
|
-exclude <module>
|
|
Don't put the specified module in the Android.bp file.
|
|
-extra-static-libs <module>=<module>[,<module>]
|
|
Some Android.bp modules have transitive static dependencies that must be specified when they
|
|
are depended upon (like android-support-v7-mediarouter requires android-support-v7-appcompat).
|
|
This may be specified multiple times to declare these dependencies.
|
|
-extra-libs <module>=<module>[,<module>]
|
|
Some Android.bp modules have transitive runtime dependencies that must be specified when they
|
|
are depended upon (like androidx.test.rules requires android.test.base).
|
|
This may be specified multiple times to declare these dependencies.
|
|
-optional-uses-libs <module>=<module>[,<module>]
|
|
Some Android.bp modules have optional dependencies (typically specified with <uses-library> in
|
|
the module's AndroidManifest.xml) that must be specified when they are depended upon (like
|
|
androidx.window:window optionally requires androidx.window:window-extensions).
|
|
This may be specified multiple times to declare these dependencies.
|
|
-sdk-version <version>
|
|
Sets sdk_version: "<version>" for all modules.
|
|
-default-min-sdk-version
|
|
The default min_sdk_version to use for a module if one cannot be mined from AndroidManifest.xml
|
|
-use-version <version>
|
|
If the maven directory contains multiple versions of artifacts and their pom files,
|
|
-use-version can be used to only write Android.bp files for a specific version of those artifacts.
|
|
-write-cmd
|
|
Whether to write the command line arguments used to generate the build file as a comment at
|
|
the top of the build file itself.
|
|
-jetifier
|
|
Sets jetifier: true for all modules.
|
|
<dir>
|
|
The directory to search for *.pom files under.
|
|
The contents are written to stdout, to be put in the current directory (often as Android.bp)
|
|
-regen <file>
|
|
Read arguments from <file> and overwrite it (if it ends with .bp) or move it to .bp (if it
|
|
ends with .mk).
|
|
|
|
`, os.Args[0])
|
|
}
|
|
|
|
var regen string
|
|
var pom2build bool
|
|
var prepend string
|
|
|
|
flag.Var(&excludes, "exclude", "Exclude module")
|
|
flag.Var(&extraStaticLibs, "extra-static-libs", "Extra static dependencies needed when depending on a module")
|
|
flag.Var(&extraLibs, "extra-libs", "Extra runtime dependencies needed when depending on a module")
|
|
flag.Var(&optionalUsesLibs, "optional-uses-libs", "Extra optional dependencies needed when depending on a module")
|
|
flag.Var(&rewriteNames, "rewrite", "Regex(es) to rewrite artifact names")
|
|
flag.Var(&hostModuleNames, "host", "Specifies that the corresponding module (specified in the form 'module.group:module.artifact') is a host module")
|
|
flag.Var(&hostAndDeviceModuleNames, "host-and-device", "Specifies that the corresponding module (specified in the form 'module.group:module.artifact') is both a host and device module.")
|
|
flag.StringVar(&sdkVersion, "sdk-version", "", "What to write to sdk_version")
|
|
flag.StringVar(&defaultMinSdkVersion, "default-min-sdk-version", "24", "Default min_sdk_version to use, if one is not available from AndroidManifest.xml. Default: 24")
|
|
flag.StringVar(&useVersion, "use-version", "", "Only read artifacts of a specific version")
|
|
flag.BoolVar(&staticDeps, "static-deps", false, "Statically include direct dependencies")
|
|
flag.BoolVar(&writeCmd, "write-cmd", true, "Write command line arguments as a comment")
|
|
flag.BoolVar(&jetifier, "jetifier", false, "Sets jetifier: true on all modules")
|
|
flag.StringVar(®en, "regen", "", "Rewrite specified file")
|
|
flag.BoolVar(&pom2build, "pom2build", false, "If true, will generate a Bazel BUILD file *instead* of a .bp file")
|
|
flag.StringVar(&prepend, "prepend", "", "Path to a file containing text to insert at the beginning of the generated build file")
|
|
flag.Parse()
|
|
|
|
if regen != "" {
|
|
err := rerunForRegen(regen)
|
|
if err != nil {
|
|
fmt.Fprintln(os.Stderr, err)
|
|
os.Exit(1)
|
|
}
|
|
os.Exit(0)
|
|
}
|
|
|
|
if flag.NArg() == 0 {
|
|
fmt.Fprintln(os.Stderr, "Directory argument is required")
|
|
os.Exit(1)
|
|
} else if flag.NArg() > 1 {
|
|
fmt.Fprintln(os.Stderr, "Multiple directories provided:", strings.Join(flag.Args(), " "))
|
|
os.Exit(1)
|
|
}
|
|
|
|
dir := flag.Arg(0)
|
|
absDir, err := filepath.Abs(dir)
|
|
if err != nil {
|
|
fmt.Fprintln(os.Stderr, "Failed to get absolute directory:", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
var filenames []string
|
|
err = filepath.Walk(absDir, func(path string, info os.FileInfo, err error) error {
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
name := info.Name()
|
|
if info.IsDir() {
|
|
if strings.HasPrefix(name, ".") {
|
|
return filepath.SkipDir
|
|
}
|
|
return nil
|
|
}
|
|
|
|
if strings.HasPrefix(name, ".") {
|
|
return nil
|
|
}
|
|
|
|
if strings.HasSuffix(name, ".pom") {
|
|
path, err = filepath.Rel(absDir, path)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
filenames = append(filenames, filepath.Join(dir, path))
|
|
}
|
|
return nil
|
|
})
|
|
if err != nil {
|
|
fmt.Fprintln(os.Stderr, "Error walking files:", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
if len(filenames) == 0 {
|
|
fmt.Fprintln(os.Stderr, "Error: no *.pom files found under", dir)
|
|
os.Exit(1)
|
|
}
|
|
|
|
sort.Strings(filenames)
|
|
|
|
poms := []*Pom{}
|
|
modules := make(map[string]*Pom)
|
|
duplicate := false
|
|
for _, filename := range filenames {
|
|
pom, err := parse(filename)
|
|
if err != nil {
|
|
fmt.Fprintln(os.Stderr, "Error converting", filename, err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
if pom != nil {
|
|
key := pom.BpName()
|
|
if excludes[key] {
|
|
continue
|
|
}
|
|
|
|
if old, ok := modules[key]; ok {
|
|
fmt.Fprintln(os.Stderr, "Module", key, "defined twice:", old.PomFile, pom.PomFile)
|
|
duplicate = true
|
|
}
|
|
|
|
poms = append(poms, pom)
|
|
modules[key] = pom
|
|
}
|
|
}
|
|
if duplicate {
|
|
os.Exit(1)
|
|
}
|
|
|
|
if pom2build {
|
|
if err := InitRefreshMod(poms); err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error in refreshmod: %s", err)
|
|
os.Exit(1)
|
|
}
|
|
BazelifyExtraDeps(extraStaticLibs, modules)
|
|
BazelifyExtraDeps(extraLibs, modules)
|
|
BazelifyExtraDeps(optionalUsesLibs, modules)
|
|
}
|
|
|
|
for _, pom := range poms {
|
|
if pom.IsAar() {
|
|
err := pom.ExtractMinSdkVersion()
|
|
if err != nil {
|
|
fmt.Fprintf(os.Stderr, "Error reading manifest for %s: %s", pom.ArtifactFile, err)
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
pom.FixDeps(modules)
|
|
if pom2build {
|
|
pom.GetBazelDepNames(modules)
|
|
}
|
|
}
|
|
|
|
buf := &bytes.Buffer{}
|
|
commentString := "//"
|
|
if pom2build {
|
|
commentString = "#"
|
|
}
|
|
|
|
fmt.Fprintln(buf, commentString, "This is a generated file. Do not modify directly.")
|
|
|
|
if writeCmd {
|
|
fmt.Fprintln(buf, commentString, "Automatically generated with:")
|
|
fmt.Fprintln(buf, commentString, "pom2bp", strings.Join(proptools.ShellEscapeList(os.Args[1:]), " "))
|
|
}
|
|
|
|
if prepend != "" {
|
|
contents, err := ioutil.ReadFile(prepend)
|
|
if err != nil {
|
|
fmt.Fprintln(os.Stderr, "Error reading", prepend, err)
|
|
os.Exit(1)
|
|
}
|
|
fmt.Fprintln(buf, string(contents))
|
|
}
|
|
|
|
depsTemplate := bpDepsTemplate
|
|
template := bpTemplate
|
|
if pom2build {
|
|
depsTemplate = bazelDepsTemplate
|
|
template = bazelTemplate
|
|
}
|
|
|
|
for _, pom := range poms {
|
|
var err error
|
|
if staticDeps && !pom.IsApk() {
|
|
err = depsTemplate.Execute(buf, pom)
|
|
} else {
|
|
err = template.Execute(buf, pom)
|
|
}
|
|
if err != nil {
|
|
fmt.Fprintln(os.Stderr, "Error writing", pom.PomFile, pom.BpName(), err)
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
|
|
if pom2build {
|
|
os.Stdout.WriteString(buf.String())
|
|
} else {
|
|
out, err := bpfix.Reformat(buf.String())
|
|
if err != nil {
|
|
fmt.Fprintln(os.Stderr, "Error formatting output", err)
|
|
os.Exit(1)
|
|
}
|
|
os.Stdout.WriteString(out)
|
|
}
|
|
|
|
}
|