Quelle  aconfig_files.go   Sprache: unbekannt

// Copyright (C) 2024 The Android Open Source Project
//
// 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 filesystem

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

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

func init() {
 pctx.HostBinToolVariable("aconfig", "aconfig")
}

var (
 aconfigCreateStorage = pctx.AndroidStaticRule("aconfig_create_storage", blueprint.RuleParams{
  Command:         `$aconfig create-storage --container $container --file $fileType --out $out --cache $in --version $version`,
  CommandDeps:     []string{"$aconfig"},
  SandboxDisabled: true,
 }, "container", "fileType", "version")

 subPartitionsInPartition = map[string][]string{
  "system": {"system_ext", "product", "vendor"},
 }
)

func (f *filesystem) buildAconfigFlagsFiles(
 ctx android.ModuleContext,
 builder *android.RuleBuilder,
 specs map[string]android.PackagingSpec,
 dir android.OutputPath,
 fullInstallPaths *[]FullInstallPathInfo,
 platformGeneratedFiles *[]string,
) {
 if !proptools.Bool(f.properties.Gen_aconfig_flags_pb) {
  return
 }

 partition := f.PartitionType()
 subPartitionsFound := map[string]bool{}
 fullInstallPath := android.PathForModuleInPartitionInstall(ctx, partition)

 for _, subPartition := range subPartitionsInPartition[partition] {
  subPartitionsFound[subPartition] = false
 }

 var caches []android.Path
 for _, ps := range specs {
  caches = append(caches, ps.GetAconfigPaths()...)
  for subPartition, found := range subPartitionsFound {
   if !found && strings.HasPrefix(ps.RelPathInPackage(), subPartition+"/") {
    subPartitionsFound[subPartition] = true
    break
   }
  }
 }
 caches = android.SortedUniquePaths(caches)

 buildAconfigFlagsFiles := func(container string, dir android.OutputPath, fullInstallPath android.InstallPath) {
  aconfigFlagsPb := android.PathForModuleOut(ctx, "aconfig", container, "aconfig_flags.pb")
  aconfigFlagsPbBuilder := android.NewRuleBuilder(pctx, ctx).SandboxDisabled()
  cmd := aconfigFlagsPbBuilder.Command().
   BuiltTool("aconfig").
   Text(" dump-cache --dedup --format protobuf --out").
   Output(aconfigFlagsPb).
   Textf("--filter container:%s+state:ENABLED", container).
   Textf("--filter container:%s+permission:READ_WRITE", container)
  for _, cache := range caches {
   cmd.FlagWithInput("--cache ", cache)
  }
  aconfigFlagsPbBuilder.Build(container+"_aconfig_flags_pb", "build aconfig_flags.pb")

  installEtcDir := dir.Join(ctx, "etc")
  installAconfigFlagsPath := installEtcDir.Join(ctx, "aconfig_flags.pb")
  builder.Command().Text("mkdir -p ").Text(installEtcDir.String())
  builder.Command().Text("cp").Input(aconfigFlagsPb).Text(installAconfigFlagsPath.String())
  installPath := fullInstallPath.Join(ctx, "etc/aconfig_flags.pb")
  *fullInstallPaths = append(*fullInstallPaths, FullInstallPathInfo{
   FullInstallPath: installPath,
   SourcePath:      aconfigFlagsPb,
  })
  f.appendToEntry(ctx, installAconfigFlagsPath)
  *platformGeneratedFiles = append(*platformGeneratedFiles, installPath.String())

  storageFilesVersion := ctx.Config().ReleaseAconfigStorageVersion()
  installAconfigStorageDir := installEtcDir.Join(ctx, "aconfig")
  builder.Command().Text("mkdir -p").Text(installAconfigStorageDir.String())

  generatePartitionAconfigStorageFile := func(fileType, fileName string) {
   outPath := android.PathForModuleOut(ctx, "aconfig", container, fileName)
   installPath := installAconfigStorageDir.Join(ctx, fileName)
   ctx.Build(pctx, android.BuildParams{
    Rule:   aconfigCreateStorage,
    Input:  aconfigFlagsPb,
    Output: outPath,
    Args: map[string]string{
     "container": container,
     "fileType":  fileType,
     "version":   storageFilesVersion,
    },
   })
   builder.Command().
    Text("cp").Input(outPath).Text(installPath.String())
   fip := fullInstallPath.Join(ctx, "etc/aconfig", fileName)
   *fullInstallPaths = append(*fullInstallPaths, FullInstallPathInfo{
    SourcePath:      outPath,
    FullInstallPath: fip,
   })
   f.appendToEntry(ctx, installPath)
   *platformGeneratedFiles = append(*platformGeneratedFiles, fip.String())
  }

  if ctx.Config().ReleaseCreateAconfigStorageFile() {
   generatePartitionAconfigStorageFile("package_map", "package.map")
   generatePartitionAconfigStorageFile("flag_map", "flag.map")
   generatePartitionAconfigStorageFile("flag_val", "flag.val")
   generatePartitionAconfigStorageFile("flag_info", "flag.info")
  }
 }

 buildAconfigFlagsFiles(partition, dir, fullInstallPath)
 for _, subPartition := range android.SortedKeys(subPartitionsFound) {
  if subPartitionsFound[subPartition] {
   buildAconfigFlagsFiles(subPartition, dir.Join(ctx, subPartition), fullInstallPath.Join(ctx, subPartition))
  }
 }
}