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

Android.bp

+2 −1

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

java/aapt2.go

+6 −4

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

	var aapt2LinkRule = pctx.AndroidStaticRule("aapt2Link",		var aapt2LinkRule = pctx.AndroidStaticRule("aapt2Link",
	blueprint.RuleParams{		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`,		`${config.SoongZipCmd} -write_if_changed -jar -o $genJar -C $genDir -D $genDir`,
	CommandDeps: []string{		CommandDeps: []string{
	"${config.Aapt2Cmd}",		"${config.Aapt2Cmd}",
	@@ -119,7 +120,7 @@ var aapt2LinkRule = pctx.AndroidStaticRule("aapt2Link",
	},		},
	Restat: true,		Restat: true,
	},		},
	"flags", "inFlags", "proguardOptions", "genDir", "genJar")		"flags", "inFlags", "proguardOptions", "genDir", "genJar", "rTxt")

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

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

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

java/aar.go

+317 −28

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

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

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

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

	func init() {		func init() {
	android.RegisterModuleType("android_library_import", AARImportFactory)		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().DefaultAppTargetSdk()})[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 {
			var versionName string
			if ctx.ModuleName() == "framework-res" {
			// Some builds set AppsDefaultVersionName() to include the build number ("O-123456"). aapt2 copies the
			// version name of framework-res into app manifests as compileSdkVersionCodename, which confuses things
			// if it contains the build number. Use the DefaultAppTargetSdk instead.
			versionName = ctx.Config().DefaultAppTargetSdk()
			} else {
			versionName = ctx.Config().AppsDefaultVersionName()
			}
			versionName = proptools.NinjaEscape([]string{versionName})[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 {		type AARImportProperties struct {
	Aars []string		Aars []string

	Sdk_version *string		Sdk_version *string

			Static_libs []string
			Libs []string
	}		}

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

			var _ AndroidLibraryDependency = (*AARImport)(nil)

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

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

	func (a *AARImport) DepsMutator(ctx android.BottomUpMutatorContext) {		func (a *AARImport) DepsMutator(ctx android.BottomUpMutatorContext) {
	// TODO: this should use decodeSdkDep once that knows about current
	if !ctx.Config().UnbundledBuild() {		if !ctx.Config().UnbundledBuild() {
	switch String(a.properties.Sdk_version) { // TODO: Res_sdk_version?		sdkDep := decodeSdkDep(ctx, String(a.properties.Sdk_version))
	case "current", "system_current", "test_current", "":		if sdkDep.useModule && sdkDep.frameworkResModule != "" {
	ctx.AddDependency(ctx.Module(), frameworkResTag, "framework-res")		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		// Unzip an AAR into its constituent files and directories. Any files in Outputs that don't exist in the AAR will be
	@@ -105,6 +408,7 @@ func (a *AARImport) GenerateAndroidBuildActions(ctx android.ModuleContext) {
	a.exportPackage = android.PathForModuleOut(ctx, "package-res.apk")		a.exportPackage = android.PathForModuleOut(ctx, "package-res.apk")
	srcJar := android.PathForModuleGen(ctx, "R.jar")		srcJar := android.PathForModuleGen(ctx, "R.jar")
	proguardOptionsFile := android.PathForModuleGen(ctx, "proguard.options")		proguardOptionsFile := android.PathForModuleGen(ctx, "proguard.options")
			rTxt := android.PathForModuleOut(ctx, "R.txt")

	var linkDeps android.Paths		var linkDeps android.Paths

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

	// Include dirs		staticLibs, libDeps, libFlags := aaptLibs(ctx, String(a.properties.Sdk_version))
	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}
	}
	}

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

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

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

	var _ Dependency = (*AARImport)(nil)		var _ Dependency = (*AARImport)(nil)

java/android_resources.go

0 → 100644

+127 −0

Original line number	Original line	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	Original line	Diff line number	Diff line
	@@ -214,7 +214,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 {		func (jd *Javadoc) AndroidMk() android.AndroidMkData {