android/aconfig_providers.go - platform/build/soong - Git at Google

 // Copyright 2023 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 android

 import (
 	"fmt"
 	"io"
 	"maps"
 	"reflect"

 	"github.com/google/blueprint"
 )

 var (
 	mergeAconfigFilesRule = pctx.AndroidStaticRule("mergeAconfigFilesRule",
 		blueprint.RuleParams{
 			Command:     `${aconfig} dump --dedup --format protobuf --out $out $flags`,
 			CommandDeps: []string{"${aconfig}"},
 		}, "flags")
 	_ = pctx.HostBinToolVariable("aconfig", "aconfig")
 )

 // Provider published by aconfig_value_set
 type AconfigDeclarationsProviderData struct {
 	Package                     string
 	Container                   string
 	Exportable                  bool
 	IntermediateCacheOutputPath WritablePath
 	IntermediateDumpOutputPath  WritablePath
 }

 var AconfigDeclarationsProviderKey = blueprint.NewProvider[AconfigDeclarationsProviderData]()

 // This is used to collect the aconfig declarations info on the transitive closure,
 // the data is keyed on the container.
 type AconfigTransitiveDeclarationsInfo struct {
 	AconfigFiles map[string]Paths
 }

 var AconfigTransitiveDeclarationsInfoProvider = blueprint.NewProvider[AconfigTransitiveDeclarationsInfo]()

 type ModeInfo struct {
 	Container string
 	Mode      string
 }
 type CodegenInfo struct {
 	// AconfigDeclarations is the name of the aconfig_declarations modules that
 	// the codegen module is associated with
 	AconfigDeclarations []string

 	// Paths to the cache files of the associated aconfig_declaration modules
 	IntermediateCacheOutputPaths Paths

 	// Paths to the srcjar files generated from the java_aconfig_library modules
 	Srcjars Paths

 	ModeInfos map[string]ModeInfo
 }

 var CodegenInfoProvider = blueprint.NewProvider[CodegenInfo]()

 func propagateModeInfos(ctx ModuleContext, module Module, to, from map[string]ModeInfo) {
 	if len(from) > 0 {
 		depTag := ctx.OtherModuleDependencyTag(module)
 		if tag, ok := depTag.(PropagateAconfigValidationDependencyTag); ok && tag.PropagateAconfigValidation() {
 			maps.Copy(to, from)
 		}
 	}
 }

 // CollectDependencyAconfigFiles is used by some module types to provide finer dependency graphing than
 // we can do in ModuleBase.
 func CollectDependencyAconfigFiles(ctx ModuleContext, mergedAconfigFiles *map[string]Paths) {
 	if *mergedAconfigFiles == nil {
 		*mergedAconfigFiles = make(map[string]Paths)
 	}
 	ctx.VisitDirectDepsIgnoreBlueprint(func(module Module) {
 		if dep, _ := OtherModuleProvider(ctx, module, AconfigDeclarationsProviderKey); dep.IntermediateCacheOutputPath != nil {
 			(*mergedAconfigFiles)[dep.Container] = append((*mergedAconfigFiles)[dep.Container], dep.IntermediateCacheOutputPath)
 			return
 		}
 		if dep, ok := OtherModuleProvider(ctx, module, aconfigPropagatingProviderKey); ok {
 			for container, v := range dep.AconfigFiles {
 				(*mergedAconfigFiles)[container] = append((*mergedAconfigFiles)[container], v...)
 			}
 		}
 		// We process these last, so that they determine the final value, eliminating any duplicates that we picked up
 		// from UpdateAndroidBuildActions.
 		if dep, ok := OtherModuleProvider(ctx, module, AconfigTransitiveDeclarationsInfoProvider); ok {
 			for container, v := range dep.AconfigFiles {
 				(*mergedAconfigFiles)[container] = append((*mergedAconfigFiles)[container], v...)
 			}
 		}
 	})

 	for _, container := range SortedKeys(*mergedAconfigFiles) {
 		aconfigFiles := (*mergedAconfigFiles)[container]
 		(*mergedAconfigFiles)[container] = mergeAconfigFiles(ctx, container, aconfigFiles, false)
 	}

 	SetProvider(ctx, AconfigTransitiveDeclarationsInfoProvider, AconfigTransitiveDeclarationsInfo{
 		AconfigFiles: *mergedAconfigFiles,
 	})
 }

 func SetAconfigFileMkEntries(m *ModuleBase, entries *AndroidMkEntries, aconfigFiles map[string]Paths) {
 	setAconfigFileMkEntries(m, entries, aconfigFiles)
 }

 type aconfigPropagatingDeclarationsInfo struct {
 	AconfigFiles map[string]Paths
 	ModeInfos    map[string]ModeInfo
 }

 var aconfigPropagatingProviderKey = blueprint.NewProvider[aconfigPropagatingDeclarationsInfo]()

 func VerifyAconfigBuildMode(ctx ModuleContext, container string, module blueprint.Module, asError bool) {
 	if dep, ok := OtherModuleProvider(ctx, module, aconfigPropagatingProviderKey); ok {
 		for k, v := range dep.ModeInfos {
 			msg := fmt.Sprintf("%s/%s depends on %s/%s/%s across containers\n",
 				module.Name(), container, k, v.Container, v.Mode)
 			if v.Container != container && v.Mode != "exported" && v.Mode != "force-read-only" {
 				if asError {
 					ctx.ModuleErrorf(msg)
 				} else {
 					fmt.Printf("WARNING: " + msg)
 				}
 			} else {
 				if !asError {
 					fmt.Printf("PASSED: " + msg)
 				}
 			}
 		}
 	}
 }

 func aconfigUpdateAndroidBuildActions(ctx ModuleContext) {
 	mergedAconfigFiles := make(map[string]Paths)
 	mergedModeInfos := make(map[string]ModeInfo)

 	ctx.VisitDirectDepsIgnoreBlueprint(func(module Module) {
 		if aconfig_dep, ok := OtherModuleProvider(ctx, module, CodegenInfoProvider); ok && len(aconfig_dep.ModeInfos) > 0 {
 			maps.Copy(mergedModeInfos, aconfig_dep.ModeInfos)
 		}

 		// If any of our dependencies have aconfig declarations (directly or propagated), then merge those and provide them.
 		if dep, ok := OtherModuleProvider(ctx, module, AconfigDeclarationsProviderKey); ok {
 			mergedAconfigFiles[dep.Container] = append(mergedAconfigFiles[dep.Container], dep.IntermediateCacheOutputPath)
 		}
 		if dep, ok := OtherModuleProvider(ctx, module, aconfigPropagatingProviderKey); ok {
 			for container, v := range dep.AconfigFiles {
 				mergedAconfigFiles[container] = append(mergedAconfigFiles[container], v...)
 			}
 			propagateModeInfos(ctx, module, mergedModeInfos, dep.ModeInfos)
 		}
 		if dep, ok := OtherModuleProvider(ctx, module, AconfigTransitiveDeclarationsInfoProvider); ok {
 			for container, v := range dep.AconfigFiles {
 				mergedAconfigFiles[container] = append(mergedAconfigFiles[container], v...)
 			}
 		}
 	})
 	// We only need to set the provider if we have aconfig files.
 	if len(mergedAconfigFiles) > 0 {
 		for _, container := range SortedKeys(mergedAconfigFiles) {
 			aconfigFiles := mergedAconfigFiles[container]
 			mergedAconfigFiles[container] = mergeAconfigFiles(ctx, container, aconfigFiles, true)
 		}

 		SetProvider(ctx, aconfigPropagatingProviderKey, aconfigPropagatingDeclarationsInfo{
 			AconfigFiles: mergedAconfigFiles,
 			ModeInfos:    mergedModeInfos,
 		})
 	}
 }

 func aconfigUpdateAndroidMkData(ctx fillInEntriesContext, mod Module, data *AndroidMkData) {
 	info, ok := SingletonModuleProvider(ctx, mod, aconfigPropagatingProviderKey)
 	// If there is no aconfigPropagatingProvider, or there are no AconfigFiles, then we are done.
 	if !ok || len(info.AconfigFiles) == 0 {
 		return
 	}
 	data.Extra = append(data.Extra, func(w io.Writer, outputFile Path) {
 		AndroidMkEmitAssignList(w, "LOCAL_ACONFIG_FILES", getAconfigFilePaths(mod.base(), info.AconfigFiles).Strings())
 	})
 	// If there is a Custom writer, it needs to support this provider.
 	if data.Custom != nil {
 		switch reflect.TypeOf(mod).String() {
 		case "*aidl.aidlApi": // writes non-custom before adding .phony
 		case "*android_sdk.sdkRepoHost": // doesn't go through base_rules
 		case "*apex.apexBundle": // aconfig_file properties written
 		case "*bpf.bpf": // properties written (both for module and objs)
 		case "*genrule.Module": // writes non-custom before adding .phony
 		case "*java.SystemModules": // doesn't go through base_rules
 		case "*phony.phony": // properties written
 		case "*phony.PhonyRule": // writes phony deps and acts like `.PHONY`
 		case "*sysprop.syspropLibrary": // properties written
 		default:
 			panic(fmt.Errorf("custom make rules do not handle aconfig files for %q (%q) module %q", ctx.ModuleType(mod), reflect.TypeOf(mod), mod))
 		}
 	}
 }

 func aconfigUpdateAndroidMkEntries(ctx fillInEntriesContext, mod Module, entries *[]AndroidMkEntries) {
 	// If there are no entries, then we can ignore this module, even if it has aconfig files.
 	if len(*entries) == 0 {
 		return
 	}
 	info, ok := SingletonModuleProvider(ctx, mod, aconfigPropagatingProviderKey)
 	if !ok || len(info.AconfigFiles) == 0 {
 		return
 	}
 	// All of the files in the module potentially depend on the aconfig flag values.
 	for idx, _ := range *entries {
 		(*entries)[idx].ExtraEntries = append((*entries)[idx].ExtraEntries,
 			func(ctx AndroidMkExtraEntriesContext, entries *AndroidMkEntries) {
 				setAconfigFileMkEntries(mod.base(), entries, info.AconfigFiles)
 			},
 		)

 	}
 }

 func mergeAconfigFiles(ctx ModuleContext, container string, inputs Paths, generateRule bool) Paths {
 	inputs = SortedUniquePaths(inputs)
 	if len(inputs) == 1 {
 		return Paths{inputs[0]}
 	}

 	output := PathForModuleOut(ctx, container, "aconfig_merged.pb")

 	if generateRule {
 		ctx.Build(pctx, BuildParams{
 			Rule:        mergeAconfigFilesRule,
 			Description: "merge aconfig files",
 			Inputs:      inputs,
 			Output:      output,
 			Args: map[string]string{
 				"flags": JoinWithPrefix(inputs.Strings(), "--cache "),
 			},
 		})
 	}

 	return Paths{output}
 }

 func setAconfigFileMkEntries(m *ModuleBase, entries *AndroidMkEntries, aconfigFiles map[string]Paths) {
 	entries.AddPaths("LOCAL_ACONFIG_FILES", getAconfigFilePaths(m, aconfigFiles))
 }

 func getAconfigFilePaths(m *ModuleBase, aconfigFiles map[string]Paths) (paths Paths) {
 	// TODO(b/311155208): The default container here should be system.
 	container := "system"

 	if m.SocSpecific() {
 		container = "vendor"
 	} else if m.ProductSpecific() {
 		container = "product"
 	} else if m.SystemExtSpecific() {
 		container = "system_ext"
 	}

 	paths = append(paths, aconfigFiles[container]...)
 	if container == "system" {
 		// TODO(b/311155208): Once the default container is system, we can drop this.
 		paths = append(paths, aconfigFiles[""]...)
 	}
 	if container != "system" {
 		if len(aconfigFiles[container]) == 0 && len(aconfigFiles[""]) > 0 {
 			// TODO(b/308625757): Either we guessed the container wrong, or the flag is misdeclared.
 			// For now, just include the system (aka "") container if we get here.
 			//fmt.Printf("container_mismatch: module=%v container=%v files=%v\n", m, container, aconfigFiles)
 		}
 		paths = append(paths, aconfigFiles[""]...)
 	}
 	return
 }
	// Copyright 2023 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 android

	import (
	"fmt"
	"io"
	"maps"
	"reflect"

	"github.com/google/blueprint"
	)

	var (
	mergeAconfigFilesRule = pctx.AndroidStaticRule("mergeAconfigFilesRule",
	blueprint.RuleParams{
	Command: `${aconfig} dump --dedup --format protobuf --out $out $flags`,
	CommandDeps: []string{"${aconfig}"},
	}, "flags")
	_ = pctx.HostBinToolVariable("aconfig", "aconfig")
	)

	// Provider published by aconfig_value_set
	type AconfigDeclarationsProviderData struct {
	Package string
	Container string
	Exportable bool
	IntermediateCacheOutputPath WritablePath
	IntermediateDumpOutputPath WritablePath
	}

	var AconfigDeclarationsProviderKey = blueprint.NewProvider[AconfigDeclarationsProviderData]()

	// This is used to collect the aconfig declarations info on the transitive closure,
	// the data is keyed on the container.
	type AconfigTransitiveDeclarationsInfo struct {
	AconfigFiles map[string]Paths
	}

	var AconfigTransitiveDeclarationsInfoProvider = blueprint.NewProvider[AconfigTransitiveDeclarationsInfo]()

	type ModeInfo struct {
	Container string
	Mode string
	}
	type CodegenInfo struct {
	// AconfigDeclarations is the name of the aconfig_declarations modules that
	// the codegen module is associated with
	AconfigDeclarations []string

	// Paths to the cache files of the associated aconfig_declaration modules
	IntermediateCacheOutputPaths Paths

	// Paths to the srcjar files generated from the java_aconfig_library modules
	Srcjars Paths

	ModeInfos map[string]ModeInfo
	}

	var CodegenInfoProvider = blueprint.NewProvider[CodegenInfo]()

	func propagateModeInfos(ctx ModuleContext, module Module, to, from map[string]ModeInfo) {
	if len(from) > 0 {
	depTag := ctx.OtherModuleDependencyTag(module)
	if tag, ok := depTag.(PropagateAconfigValidationDependencyTag); ok && tag.PropagateAconfigValidation() {
	maps.Copy(to, from)
	}
	}
	}

	// CollectDependencyAconfigFiles is used by some module types to provide finer dependency graphing than
	// we can do in ModuleBase.
	func CollectDependencyAconfigFiles(ctx ModuleContext, mergedAconfigFiles *map[string]Paths) {
	if *mergedAconfigFiles == nil {
	*mergedAconfigFiles = make(map[string]Paths)
	}
	ctx.VisitDirectDepsIgnoreBlueprint(func(module Module) {
	if dep, _ := OtherModuleProvider(ctx, module, AconfigDeclarationsProviderKey); dep.IntermediateCacheOutputPath != nil {
	(mergedAconfigFiles)[dep.Container] = append((mergedAconfigFiles)[dep.Container], dep.IntermediateCacheOutputPath)
	return
	}
	if dep, ok := OtherModuleProvider(ctx, module, aconfigPropagatingProviderKey); ok {
	for container, v := range dep.AconfigFiles {
	(mergedAconfigFiles)[container] = append((mergedAconfigFiles)[container], v...)
	}
	}
	// We process these last, so that they determine the final value, eliminating any duplicates that we picked up
	// from UpdateAndroidBuildActions.
	if dep, ok := OtherModuleProvider(ctx, module, AconfigTransitiveDeclarationsInfoProvider); ok {
	for container, v := range dep.AconfigFiles {
	(mergedAconfigFiles)[container] = append((mergedAconfigFiles)[container], v...)
	}
	}
	})

	for _, container := range SortedKeys(*mergedAconfigFiles) {
	aconfigFiles := (*mergedAconfigFiles)[container]
	(*mergedAconfigFiles)[container] = mergeAconfigFiles(ctx, container, aconfigFiles, false)
	}

	SetProvider(ctx, AconfigTransitiveDeclarationsInfoProvider, AconfigTransitiveDeclarationsInfo{
	AconfigFiles: *mergedAconfigFiles,
	})
	}

	func SetAconfigFileMkEntries(m ModuleBase, entries AndroidMkEntries, aconfigFiles map[string]Paths) {
	setAconfigFileMkEntries(m, entries, aconfigFiles)
	}

	type aconfigPropagatingDeclarationsInfo struct {
	AconfigFiles map[string]Paths
	ModeInfos map[string]ModeInfo
	}

	var aconfigPropagatingProviderKey = blueprint.NewProvider[aconfigPropagatingDeclarationsInfo]()

	func VerifyAconfigBuildMode(ctx ModuleContext, container string, module blueprint.Module, asError bool) {
	if dep, ok := OtherModuleProvider(ctx, module, aconfigPropagatingProviderKey); ok {
	for k, v := range dep.ModeInfos {
	msg := fmt.Sprintf("%s/%s depends on %s/%s/%s across containers\n",
	module.Name(), container, k, v.Container, v.Mode)
	if v.Container != container && v.Mode != "exported" && v.Mode != "force-read-only" {
	if asError {
	ctx.ModuleErrorf(msg)
	} else {
	fmt.Printf("WARNING: " + msg)
	}
	} else {
	if !asError {
	fmt.Printf("PASSED: " + msg)
	}
	}
	}
	}
	}

	func aconfigUpdateAndroidBuildActions(ctx ModuleContext) {
	mergedAconfigFiles := make(map[string]Paths)
	mergedModeInfos := make(map[string]ModeInfo)

	ctx.VisitDirectDepsIgnoreBlueprint(func(module Module) {
	if aconfig_dep, ok := OtherModuleProvider(ctx, module, CodegenInfoProvider); ok && len(aconfig_dep.ModeInfos) > 0 {
	maps.Copy(mergedModeInfos, aconfig_dep.ModeInfos)
	}

	// If any of our dependencies have aconfig declarations (directly or propagated), then merge those and provide them.
	if dep, ok := OtherModuleProvider(ctx, module, AconfigDeclarationsProviderKey); ok {
	mergedAconfigFiles[dep.Container] = append(mergedAconfigFiles[dep.Container], dep.IntermediateCacheOutputPath)
	}
	if dep, ok := OtherModuleProvider(ctx, module, aconfigPropagatingProviderKey); ok {
	for container, v := range dep.AconfigFiles {
	mergedAconfigFiles[container] = append(mergedAconfigFiles[container], v...)
	}
	propagateModeInfos(ctx, module, mergedModeInfos, dep.ModeInfos)
	}
	if dep, ok := OtherModuleProvider(ctx, module, AconfigTransitiveDeclarationsInfoProvider); ok {
	for container, v := range dep.AconfigFiles {
	mergedAconfigFiles[container] = append(mergedAconfigFiles[container], v...)
	}
	}
	})
	// We only need to set the provider if we have aconfig files.
	if len(mergedAconfigFiles) > 0 {
	for _, container := range SortedKeys(mergedAconfigFiles) {
	aconfigFiles := mergedAconfigFiles[container]
	mergedAconfigFiles[container] = mergeAconfigFiles(ctx, container, aconfigFiles, true)
	}

	SetProvider(ctx, aconfigPropagatingProviderKey, aconfigPropagatingDeclarationsInfo{
	AconfigFiles: mergedAconfigFiles,
	ModeInfos: mergedModeInfos,
	})
	}
	}

	func aconfigUpdateAndroidMkData(ctx fillInEntriesContext, mod Module, data *AndroidMkData) {
	info, ok := SingletonModuleProvider(ctx, mod, aconfigPropagatingProviderKey)
	// If there is no aconfigPropagatingProvider, or there are no AconfigFiles, then we are done.
	if !ok \|\| len(info.AconfigFiles) == 0 {
	return
	}
	data.Extra = append(data.Extra, func(w io.Writer, outputFile Path) {
	AndroidMkEmitAssignList(w, "LOCAL_ACONFIG_FILES", getAconfigFilePaths(mod.base(), info.AconfigFiles).Strings())
	})
	// If there is a Custom writer, it needs to support this provider.
	if data.Custom != nil {
	switch reflect.TypeOf(mod).String() {
	case "*aidl.aidlApi": // writes non-custom before adding .phony
	case "*android_sdk.sdkRepoHost": // doesn't go through base_rules
	case "*apex.apexBundle": // aconfig_file properties written
	case "*bpf.bpf": // properties written (both for module and objs)
	case "*genrule.Module": // writes non-custom before adding .phony
	case "*java.SystemModules": // doesn't go through base_rules
	case "*phony.phony": // properties written
	case "*phony.PhonyRule": // writes phony deps and acts like `.PHONY`
	case "*sysprop.syspropLibrary": // properties written
	default:
	panic(fmt.Errorf("custom make rules do not handle aconfig files for %q (%q) module %q", ctx.ModuleType(mod), reflect.TypeOf(mod), mod))
	}
	}
	}

	func aconfigUpdateAndroidMkEntries(ctx fillInEntriesContext, mod Module, entries *[]AndroidMkEntries) {
	// If there are no entries, then we can ignore this module, even if it has aconfig files.
	if len(*entries) == 0 {
	return
	}
	info, ok := SingletonModuleProvider(ctx, mod, aconfigPropagatingProviderKey)
	if !ok \|\| len(info.AconfigFiles) == 0 {
	return
	}
	// All of the files in the module potentially depend on the aconfig flag values.
	for idx, _ := range *entries {
	(entries)[idx].ExtraEntries = append((entries)[idx].ExtraEntries,
	func(ctx AndroidMkExtraEntriesContext, entries *AndroidMkEntries) {
	setAconfigFileMkEntries(mod.base(), entries, info.AconfigFiles)
	},
	)

	}
	}

	func mergeAconfigFiles(ctx ModuleContext, container string, inputs Paths, generateRule bool) Paths {
	inputs = SortedUniquePaths(inputs)
	if len(inputs) == 1 {
	return Paths{inputs[0]}
	}

	output := PathForModuleOut(ctx, container, "aconfig_merged.pb")

	if generateRule {
	ctx.Build(pctx, BuildParams{
	Rule: mergeAconfigFilesRule,
	Description: "merge aconfig files",
	Inputs: inputs,
	Output: output,
	Args: map[string]string{
	"flags": JoinWithPrefix(inputs.Strings(), "--cache "),
	},
	})
	}

	return Paths{output}
	}

	func setAconfigFileMkEntries(m ModuleBase, entries AndroidMkEntries, aconfigFiles map[string]Paths) {
	entries.AddPaths("LOCAL_ACONFIG_FILES", getAconfigFilePaths(m, aconfigFiles))
	}

	func getAconfigFilePaths(m *ModuleBase, aconfigFiles map[string]Paths) (paths Paths) {
	// TODO(b/311155208): The default container here should be system.
	container := "system"

	if m.SocSpecific() {
	container = "vendor"
	} else if m.ProductSpecific() {
	container = "product"
	} else if m.SystemExtSpecific() {
	container = "system_ext"
	}

	paths = append(paths, aconfigFiles[container]...)
	if container == "system" {
	// TODO(b/311155208): Once the default container is system, we can drop this.
	paths = append(paths, aconfigFiles[""]...)
	}
	if container != "system" {
	if len(aconfigFiles[container]) == 0 && len(aconfigFiles[""]) > 0 {
	// TODO(b/308625757): Either we guessed the container wrong, or the flag is misdeclared.
	// For now, just include the system (aka "") container if we get here.
	//fmt.Printf("container_mismatch: module=%v container=%v files=%v\n", m, container, aconfigFiles)
	}
	paths = append(paths, aconfigFiles[""]...)
	}
	return
	}