Add support for android_library modules (a97c5d3f) · Commits · e / os / android_build_soong

Android.bp

+2 −1

Original line number	Diff line number	Diff line
		@@ -219,6 +219,7 @@ bootstrap_go_package {
		srcs: [
		"java/aapt2.go",
		"java/aar.go",
		"java/android_resources.go",
		"java/androidmk.go",
		"java/app_builder.go",
		"java/app.go",
		@@ -229,8 +230,8 @@ bootstrap_go_package {
		"java/genrule.go",
		"java/jacoco.go",
		"java/java.go",
		"java/java_resources.go",
		"java/proto.go",
		"java/resources.go",
		"java/system_modules.go",
		],
		testSrcs: [

java/aapt2.go

+6 −4

Original line number	Diff line number	Diff line
		@@ -111,7 +111,8 @@ func aapt2CompileDirs(ctx android.ModuleContext, flata android.WritablePath, dir

		var aapt2LinkRule = pctx.AndroidStaticRule("aapt2Link",
		blueprint.RuleParams{
		Command: `${config.Aapt2Cmd} link -o $out $flags --java $genDir --proguard $proguardOptions $inFlags && ` +
		Command: `${config.Aapt2Cmd} link -o $out $flags --java $genDir --proguard $proguardOptions ` +
		`--output-text-symbols ${rTxt} $inFlags && ` +
		`${config.SoongZipCmd} -write_if_changed -jar -o $genJar -C $genDir -D $genDir`,
		CommandDeps: []string{
		"${config.Aapt2Cmd}",
		@@ -119,7 +120,7 @@ var aapt2LinkRule = pctx.AndroidStaticRule("aapt2Link",
		},
		Restat: true,
		},
		"flags", "inFlags", "proguardOptions", "genDir", "genJar")
		"flags", "inFlags", "proguardOptions", "genDir", "genJar", "rTxt")

		var fileListToFileRule = pctx.AndroidStaticRule("fileListToFile",
		blueprint.RuleParams{
		@@ -129,7 +130,7 @@ var fileListToFileRule = pctx.AndroidStaticRule("fileListToFile",
		})

		func aapt2Link(ctx android.ModuleContext,
		packageRes, genJar, proguardOptions android.WritablePath,
		packageRes, genJar, proguardOptions, rTxt android.WritablePath,
		flags []string, deps android.Paths,
		compiledRes, compiledOverlay android.Paths) {

		@@ -171,13 +172,14 @@ func aapt2Link(ctx android.ModuleContext,
		Description: "aapt2 link",
		Implicits: deps,
		Output: packageRes,
		ImplicitOutputs: android.WritablePaths{proguardOptions, genJar},
		ImplicitOutputs: android.WritablePaths{proguardOptions, genJar, rTxt},
		Args: map[string]string{
		"flags": strings.Join(flags, " "),
		"inFlags": strings.Join(inFlags, " "),
		"proguardOptions": proguardOptions.String(),
		"genDir": genDir.String(),
		"genJar": genJar.String(),
		"rTxt": rTxt.String(),
		},
		})
		}

java/aar.go

+308 −28

Original line number	Diff line number	Diff line
		@@ -16,21 +16,307 @@ package java

		import (
		"android/soong/android"
		"strings"

		"github.com/google/blueprint"
		"github.com/google/blueprint/proptools"
		)

		//
		// AAR (android library) prebuilts
		//
		type AndroidLibraryDependency interface {
		Dependency
		ExportPackage() android.Path
		}

		func init() {
		android.RegisterModuleType("android_library_import", AARImportFactory)
		android.RegisterModuleType("android_library", AndroidLibraryFactory)
		}

		//
		// AAR (android library)
		//

		type androidLibraryProperties struct {
		BuildAAR bool `blueprint:"mutated"`
		}

		type aaptProperties struct {
		// flags passed to aapt when creating the apk
		Aaptflags []string

		// list of directories relative to the Blueprints file containing assets.
		// Defaults to "assets"
		Asset_dirs []string

		// list of directories relative to the Blueprints file containing
		// Android resources
		Resource_dirs []string

		// path to AndroidManifest.xml. If unset, defaults to "AndroidManifest.xml".
		Manifest *string
		}

		type aapt struct {
		aaptSrcJar android.Path
		exportPackage android.Path
		manifestPath android.Path
		proguardOptionsFile android.Path
		rroDirs android.Paths
		rTxt android.Path

		aaptProperties aaptProperties
		}

		func (a *aapt) ExportPackage() android.Path {
		return a.exportPackage
		}

		func (a *aapt) aapt2Flags(ctx android.ModuleContext, sdkVersion string) (flags []string, deps android.Paths,
		resDirs, overlayDirs []globbedResourceDir, overlayFiles, rroDirs android.Paths, manifestPath android.Path) {

		hasVersionCode := false
		hasVersionName := false
		hasProduct := false
		for _, f := range a.aaptProperties.Aaptflags {
		if strings.HasPrefix(f, "--version-code") {
		hasVersionCode = true
		} else if strings.HasPrefix(f, "--version-name") {
		hasVersionName = true
		} else if strings.HasPrefix(f, "--product") {
		hasProduct = true
		}
		}

		var linkFlags []string

		// Flags specified in Android.bp
		linkFlags = append(linkFlags, a.aaptProperties.Aaptflags...)

		linkFlags = append(linkFlags, "--no-static-lib-packages")

		// Find implicit or explicit asset and resource dirs
		assetDirs := android.PathsWithOptionalDefaultForModuleSrc(ctx, a.aaptProperties.Asset_dirs, "assets")
		resourceDirs := android.PathsWithOptionalDefaultForModuleSrc(ctx, a.aaptProperties.Resource_dirs, "res")

		var linkDeps android.Paths

		// Glob directories into lists of paths
		for _, dir := range resourceDirs {
		resDirs = append(resDirs, globbedResourceDir{
		dir: dir,
		files: androidResourceGlob(ctx, dir),
		})
		resOverlayDirs, resRRODirs := overlayResourceGlob(ctx, dir)
		overlayDirs = append(overlayDirs, resOverlayDirs...)
		rroDirs = append(rroDirs, resRRODirs...)
		}

		var assetFiles android.Paths
		for _, dir := range assetDirs {
		assetFiles = append(assetFiles, androidResourceGlob(ctx, dir)...)
		}

		// App manifest file
		manifestFile := proptools.StringDefault(a.aaptProperties.Manifest, "AndroidManifest.xml")
		manifestPath = android.PathForModuleSrc(ctx, manifestFile)
		linkFlags = append(linkFlags, "--manifest "+manifestPath.String())
		linkDeps = append(linkDeps, manifestPath)

		linkFlags = append(linkFlags, android.JoinWithPrefix(assetDirs.Strings(), "-A "))
		linkDeps = append(linkDeps, assetFiles...)

		staticLibs, libDeps, libFlags := aaptLibs(ctx, sdkVersion)

		overlayFiles = append(overlayFiles, staticLibs...)
		linkDeps = append(linkDeps, libDeps...)
		linkFlags = append(linkFlags, libFlags...)

		// SDK version flags
		switch sdkVersion {
		case "", "current", "system_current", "test_current":
		sdkVersion = proptools.NinjaEscape([]string{ctx.Config().AppsDefaultVersionName()})[0]
		}

		linkFlags = append(linkFlags, "--min-sdk-version "+sdkVersion)
		linkFlags = append(linkFlags, "--target-sdk-version "+sdkVersion)

		// Product characteristics
		if !hasProduct && len(ctx.Config().ProductAAPTCharacteristics()) > 0 {
		linkFlags = append(linkFlags, "--product", ctx.Config().ProductAAPTCharacteristics())
		}

		// Product AAPT config
		for _, aaptConfig := range ctx.Config().ProductAAPTConfig() {
		linkFlags = append(linkFlags, "-c", aaptConfig)
		}

		// Product AAPT preferred config
		if len(ctx.Config().ProductAAPTPreferredConfig()) > 0 {
		linkFlags = append(linkFlags, "--preferred-density", ctx.Config().ProductAAPTPreferredConfig())
		}

		// Version code
		if !hasVersionCode {
		linkFlags = append(linkFlags, "--version-code", ctx.Config().PlatformSdkVersion())
		}

		if !hasVersionName {
		versionName := proptools.NinjaEscape([]string{ctx.Config().AppsDefaultVersionName()})[0]
		linkFlags = append(linkFlags, "--version-name ", versionName)
		}

		return linkFlags, linkDeps, resDirs, overlayDirs, overlayFiles, rroDirs, manifestPath
		}

		func (a *aapt) deps(ctx android.BottomUpMutatorContext, sdkVersion string) {
		if !ctx.Config().UnbundledBuild() {
		sdkDep := decodeSdkDep(ctx, sdkVersion)
		if sdkDep.frameworkResModule != "" {
		ctx.AddDependency(ctx.Module(), frameworkResTag, sdkDep.frameworkResModule)
		}
		}
		}

		func (a *aapt) buildActions(ctx android.ModuleContext, sdkVersion string, extraLinkFlags ...string) {
		linkFlags, linkDeps, resDirs, overlayDirs, overlayFiles, rroDirs, manifestPath := a.aapt2Flags(ctx, sdkVersion)

		linkFlags = append(linkFlags, extraLinkFlags...)

		packageRes := android.PathForModuleOut(ctx, "package-res.apk")
		srcJar := android.PathForModuleGen(ctx, "R.jar")
		proguardOptionsFile := android.PathForModuleGen(ctx, "proguard.options")
		rTxt := android.PathForModuleOut(ctx, "R.txt")

		var compiledRes, compiledOverlay android.Paths
		for _, dir := range resDirs {
		compiledRes = append(compiledRes, aapt2Compile(ctx, dir.dir, dir.files).Paths()...)
		}
		for _, dir := range overlayDirs {
		compiledOverlay = append(compiledOverlay, aapt2Compile(ctx, dir.dir, dir.files).Paths()...)
		}

		compiledOverlay = append(compiledOverlay, overlayFiles...)

		aapt2Link(ctx, packageRes, srcJar, proguardOptionsFile, rTxt,
		linkFlags, linkDeps, compiledRes, compiledOverlay)

		a.aaptSrcJar = srcJar
		a.exportPackage = packageRes
		a.manifestPath = manifestPath
		a.proguardOptionsFile = proguardOptionsFile
		a.rroDirs = rroDirs
		a.rTxt = rTxt
		}

		// aaptLibs collects libraries from dependencies and sdk_version and converts them into paths
		func aaptLibs(ctx android.ModuleContext, sdkVersion string) (staticLibs, deps android.Paths, flags []string) {
		var sharedLibs android.Paths

		sdkDep := decodeSdkDep(ctx, sdkVersion)
		if sdkDep.useFiles {
		sharedLibs = append(sharedLibs, sdkDep.jar)
		}

		ctx.VisitDirectDeps(func(module android.Module) {
		var exportPackage android.Path
		if aarDep, ok := module.(AndroidLibraryDependency); ok {
		exportPackage = aarDep.ExportPackage()
		}

		switch ctx.OtherModuleDependencyTag(module) {
		case libTag, frameworkResTag:
		if exportPackage != nil {
		sharedLibs = append(sharedLibs, exportPackage)
		}
		case staticLibTag:
		if exportPackage != nil {
		staticLibs = append(staticLibs, exportPackage)
		}
		}
		})

		deps = append(deps, sharedLibs...)
		deps = append(deps, staticLibs...)

		if len(staticLibs) > 0 {
		flags = append(flags, "--auto-add-overlay")
		}

		for _, sharedLib := range sharedLibs {
		flags = append(flags, "-I "+sharedLib.String())
		}

		return staticLibs, deps, flags
		}

		type AndroidLibrary struct {
		Library
		aapt

		androidLibraryProperties androidLibraryProperties

		aarFile android.WritablePath
		}

		var _ AndroidLibraryDependency = (*AndroidLibrary)(nil)

		func (a *AndroidLibrary) DepsMutator(ctx android.BottomUpMutatorContext) {
		a.Module.deps(ctx)
		if !Bool(a.properties.No_framework_libs) && !Bool(a.properties.No_standard_libs) {
		a.aapt.deps(ctx, String(a.deviceProperties.Sdk_version))
		}
		}

		func (a *AndroidLibrary) GenerateAndroidBuildActions(ctx android.ModuleContext) {
		a.aapt.buildActions(ctx, String(a.deviceProperties.Sdk_version), "--static-lib")

		ctx.CheckbuildFile(a.proguardOptionsFile)
		ctx.CheckbuildFile(a.exportPackage)
		ctx.CheckbuildFile(a.aaptSrcJar)

		// apps manifests are handled by aapt, don't let Module see them
		a.properties.Manifest = nil

		a.Module.extraProguardFlagFiles = append(a.Module.extraProguardFlagFiles,
		a.proguardOptionsFile)

		a.Module.compile(ctx, a.aaptSrcJar)

		a.aarFile = android.PathForOutput(ctx, ctx.ModuleName()+".aar")
		var res android.Paths
		if a.androidLibraryProperties.BuildAAR {
		BuildAAR(ctx, a.aarFile, a.outputFile, a.manifestPath, a.rTxt, res)
		ctx.CheckbuildFile(a.aarFile)
		}
		}

		func AndroidLibraryFactory() android.Module {
		module := &AndroidLibrary{}

		module.AddProperties(
		&module.Module.properties,
		&module.Module.deviceProperties,
		&module.Module.protoProperties,
		&module.aaptProperties,
		&module.androidLibraryProperties)

		module.androidLibraryProperties.BuildAAR = true

		android.InitAndroidArchModule(module, android.DeviceSupported, android.MultilibCommon)
		return module
		}

		//
		// AAR (android library) prebuilts
		//

		type AARImportProperties struct {
		Aars []string

		Sdk_version *string

		Static_libs []string
		Libs []string
		}

		type AARImport struct {
		@@ -44,6 +330,12 @@ type AARImport struct {
		exportPackage android.WritablePath
		}

		var _ AndroidLibraryDependency = (*AARImport)(nil)

		func (a *AARImport) ExportPackage() android.Path {
		return a.exportPackage
		}

		func (a AARImport) Prebuilt() android.Prebuilt {
		return &a.prebuilt
		}
		@@ -53,13 +345,15 @@ func (a *AARImport) Name() string {
		}

		func (a *AARImport) DepsMutator(ctx android.BottomUpMutatorContext) {
		// TODO: this should use decodeSdkDep once that knows about current
		if !ctx.Config().UnbundledBuild() {
		switch String(a.properties.Sdk_version) { // TODO: Res_sdk_version?
		case "current", "system_current", "test_current", "":
		ctx.AddDependency(ctx.Module(), frameworkResTag, "framework-res")
		sdkDep := decodeSdkDep(ctx, String(a.properties.Sdk_version))
		if sdkDep.useModule && sdkDep.frameworkResModule != "" {
		ctx.AddDependency(ctx.Module(), frameworkResTag, sdkDep.frameworkResModule)
		}
		}

		ctx.AddDependency(ctx.Module(), staticLibTag, a.properties.Libs...)
		ctx.AddDependency(ctx.Module(), staticLibTag, a.properties.Static_libs...)
		}

		// Unzip an AAR into its constituent files and directories. Any files in Outputs that don't exist in the AAR will be
		@@ -105,6 +399,7 @@ func (a *AARImport) GenerateAndroidBuildActions(ctx android.ModuleContext) {
		a.exportPackage = android.PathForModuleOut(ctx, "package-res.apk")
		srcJar := android.PathForModuleGen(ctx, "R.jar")
		proguardOptionsFile := android.PathForModuleGen(ctx, "proguard.options")
		rTxt := android.PathForModuleOut(ctx, "R.txt")

		var linkDeps android.Paths

		@@ -117,30 +412,15 @@ func (a *AARImport) GenerateAndroidBuildActions(ctx android.ModuleContext) {
		linkFlags = append(linkFlags, "--manifest "+manifest.String())
		linkDeps = append(linkDeps, manifest)

		// Include dirs
		ctx.VisitDirectDeps(func(module android.Module) {
		var depFiles android.Paths
		if javaDep, ok := module.(Dependency); ok {
		// TODO: shared android libraries
		if ctx.OtherModuleName(module) == "framework-res" {
		depFiles = android.Paths{javaDep.(*AndroidApp).exportPackage}
		}
		}
		staticLibs, libDeps, libFlags := aaptLibs(ctx, String(a.properties.Sdk_version))

		for _, dep := range depFiles {
		linkFlags = append(linkFlags, "-I "+dep.String())
		}
		linkDeps = append(linkDeps, depFiles...)
		})
		linkDeps = append(linkDeps, libDeps...)
		linkFlags = append(linkFlags, libFlags...)

		sdkDep := decodeSdkDep(ctx, String(a.properties.Sdk_version))
		if sdkDep.useFiles {
		linkFlags = append(linkFlags, "-I "+sdkDep.jar.String())
		linkDeps = append(linkDeps, sdkDep.jar)
		}
		overlayRes := append(android.Paths{flata}, staticLibs...)

		aapt2Link(ctx, a.exportPackage, srcJar, proguardOptionsFile,
		linkFlags, linkDeps, nil, android.Paths{flata})
		aapt2Link(ctx, a.exportPackage, srcJar, proguardOptionsFile, rTxt,
		linkFlags, linkDeps, nil, overlayRes)
		}

		var _ Dependency = (*AARImport)(nil)

java/android_resources.go

0 → 100644

+127 −0

Original line number	Diff line number	Diff line
		// Copyright 2018 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

		import (
		"path/filepath"
		"strings"

		"android/soong/android"
		)

		func init() {
		android.RegisterPreSingletonType("overlay", OverlaySingletonFactory)
		}

		var androidResourceIgnoreFilenames = []string{
		".svn",
		".git",
		".ds_store",
		"*.scc",
		".*",
		"CVS",
		"thumbs.db",
		"picasa.ini",
		"*~",
		}

		func androidResourceGlob(ctx android.ModuleContext, dir android.Path) android.Paths {
		return ctx.GlobFiles(filepath.Join(dir.String(), "*/"), androidResourceIgnoreFilenames)
		}

		type overlayGlobResult struct {
		dir string
		paths android.DirectorySortedPaths

		// Set to true of the product has selected that values in this overlay should not be moved to
		// Runtime Resource Overlay (RRO) packages.
		excludeFromRRO bool
		}

		const overlayDataKey = "overlayDataKey"

		type globbedResourceDir struct {
		dir android.Path
		files android.Paths
		}

		func overlayResourceGlob(ctx android.ModuleContext, dir android.Path) (res []globbedResourceDir,
		rroDirs android.Paths) {

		overlayData := ctx.Config().Get(overlayDataKey).([]overlayGlobResult)

		// Runtime resource overlays (RRO) may be turned on by the product config for some modules
		rroEnabled := ctx.Config().EnforceRROForModule(ctx.ModuleName())

		for _, data := range overlayData {
		files := data.paths.PathsInDirectory(filepath.Join(data.dir, dir.String()))
		if len(files) > 0 {
		overlayModuleDir := android.PathForSource(ctx, data.dir, dir.String())
		// If enforce RRO is enabled for this module and this overlay is not in the
		// exclusion list, ignore the overlay. The list of ignored overlays will be
		// passed to Make to be turned into an RRO package.
		if rroEnabled && !data.excludeFromRRO {
		rroDirs = append(rroDirs, overlayModuleDir)
		} else {
		res = append(res, globbedResourceDir{
		dir: overlayModuleDir,
		files: files,
		})
		}
		}
		}

		return res, rroDirs
		}

		func OverlaySingletonFactory() android.Singleton {
		return overlaySingleton{}
		}

		type overlaySingleton struct{}

		func (overlaySingleton) GenerateBuildActions(ctx android.SingletonContext) {
		var overlayData []overlayGlobResult
		overlayDirs := ctx.Config().ResourceOverlays()
		for i := range overlayDirs {
		// Iterate backwards through the list of overlay directories so that the later, lower-priority
		// directories in the list show up earlier in the command line to aapt2.
		overlay := overlayDirs[len(overlayDirs)-1-i]
		var result overlayGlobResult
		result.dir = overlay

		// Mark overlays that will not have Runtime Resource Overlays enforced on them
		// based on the product config
		result.excludeFromRRO = ctx.Config().EnforceRROExcludedOverlay(overlay)

		files, err := ctx.GlobWithDeps(filepath.Join(overlay, "*/"), androidResourceIgnoreFilenames)
		if err != nil {
		ctx.Errorf("failed to glob resource dir %q: %s", overlay, err.Error())
		continue
		}
		var paths android.Paths
		for _, f := range files {
		if !strings.HasSuffix(f, "/") {
		paths = append(paths, android.PathForSource(ctx, f))
		}
		}
		result.paths = android.PathsToDirectorySortedPaths(paths)
		overlayData = append(overlayData, result)
		}

		ctx.Config().Once(overlayDataKey, func() interface{} {
		return overlayData
		})
		}

java/androidmk.go

+24 −0

Original line number	Diff line number	Diff line
		@@ -223,7 +223,31 @@ func (app *AndroidApp) AndroidMk() android.AndroidMkData {
		},
		},
		}
		}

		func (a *AndroidLibrary) AndroidMk() android.AndroidMkData {
		data := a.Library.AndroidMk()

		data.Extra = append(data.Extra, func(w io.Writer, outputFile android.Path) {
		if a.proguardDictionary != nil {
		fmt.Fprintln(w, "LOCAL_SOONG_PROGUARD_DICT :=", a.proguardDictionary.String())
		}

		if a.Name() == "framework-res" {
		fmt.Fprintln(w, "LOCAL_MODULE_PATH := $(TARGET_OUT_JAVA_LIBRARIES)")
		// Make base_rules.mk not put framework-res in a subdirectory called
		// framework_res.
		fmt.Fprintln(w, "LOCAL_NO_STANDARD_LIBRARIES := true")
		}

		fmt.Fprintln(w, "LOCAL_SOONG_RESOURCE_EXPORT_PACKAGE :=", a.exportPackage.String())
		fmt.Fprintln(w, "LOCAL_FULL_MANIFEST_FILE :=", a.manifestPath.String())
		fmt.Fprintln(w, "LOCAL_SOONG_EXPORT_PROGUARD_FLAGS :=", a.proguardOptionsFile.String())
		fmt.Fprintln(w, "LOCAL_UNINSTALLABLE_MODULE := true")
		fmt.Fprintln(w, "LOCAL_DEX_PREOPT := false")
		})

		return data
		}

		func (jd *Javadoc) AndroidMk() android.AndroidMkData {