Quelle  unbundled.go   Sprache: unbekannt

// Copyright 2025 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 unbundled

import (
 "fmt"
 "slices"

 "github.com/google/blueprint"

 "android/soong/android"
 "android/soong/cc"
 "android/soong/filesystem"
 "android/soong/java"
)

var pctx = android.NewPackageContext("android/soong/unbundled")

func init() {
 pctx.Import("android/soong/android")
 registerUnbundledBuilder(android.InitRegistrationContext)
}

func registerUnbundledBuilder(ctx android.RegistrationContext) {
 ctx.RegisterModuleType("unbundled_builder", unbundledBuilderFactory)
}

func unbundledBuilderFactory() android.Module {
 m := &unbundledBuilder{}
 android.InitAndroidModule(m)
 return m
}

// unbundledBuilder handles building and disting certain artifacts for "unbundled builds".
// unbundled builds are builds that aren't for a specific device, such as when you just want to
// build an app or an apex.
type unbundledBuilder struct {
 android.ModuleBase
}

type unbundledDepTagType struct {
 blueprint.BaseDependencyTag
}

func (unbundledDepTagType) ExcludeFromVisibilityEnforcement() {}

var _ android.ExcludeFromVisibilityEnforcementTag = unbundledDepTagType{}

func (unbundledDepTagType) UsesUnbundledVariant() {}

var _ android.UsesUnbundledVariantDepTag = unbundledDepTagType{}

var unbundledDepTag = unbundledDepTagType{}

// We need to implement IsNativeCoverageNeeded so that in coverage builds we depend on the coverage
// variants of the unbundled apps. Only the coverage variants export symbols info.
func (p *unbundledBuilder) IsNativeCoverageNeeded(ctx cc.IsNativeCoverageNeededContext) bool {
 return ctx.DeviceConfig().NativeCoverageEnabled()
}

// Return "false" for UseGenericConfig() to read the DeviceProduct().
// Even though unbundledBuilder is not for a specific device, do we need "targetProductPrefix"?
func (p *unbundledBuilder) UseGenericConfig() bool {
 return false
}

var _ cc.UseCoverage = (*unbundledBuilder)(nil)

func (*unbundledBuilder) DepsMutator(ctx android.BottomUpMutatorContext) {
 apps := ctx.Config().UnbundledBuildApps()
 apps = slices.Clone(apps)
 slices.Sort(apps)

 for _, app := range apps {
  // Add a dependency on the app so we can get its providers later.
  // unbundledDepTag implements android.UsesUnbundledVariantDepTag, which causes the
  // os, arch, and sdk mutators to pick the most appropriate variants to use for unbundled
  // builds. unbundledBuilder itself also implements cc.UseCoverage, which forces coverage
  // variants of deps.
  ctx.AddDependency(ctx.Module(), unbundledDepTag, app)
 }
}

func (*unbundledBuilder) GenerateAndroidBuildActions(ctx android.ModuleContext) {
 ctx.Module().HideFromMake()
 if ctx.ModuleDir() != "build/soong/unbundled" {
  ctx.ModuleErrorf("There can only be 1 unbundled_builder in build/soong/unbundled")
  return
 }
 if !ctx.Config().HasUnbundledBuildApps() {
  return
 }

 var appModules []android.ModuleProxy
 ctx.VisitDirectDepsProxyWithTag(unbundledDepTag, func(m android.ModuleProxy) {
  appModules = append(appModules, m)
 })

 targetProductPrefix := ""
 if ctx.Config().HasDeviceProduct() {
  targetProductPrefix = ctx.Config().DeviceProduct()
  if ctx.Config().BuildType() == "debug" {
   targetProductPrefix += "_debug"
  }
  targetProductPrefix += "-"
 }

 // Dist installed files, bundles, and AARs
 for _, app := range appModules {
  name := android.OtherModuleNameWithPossibleOverride(ctx, app)
  if bundleInfo, ok := android.OtherModuleProvider(ctx, app, java.BundleProvider); ok {
   ctx.DistForGoalWithFilename("apps_only", bundleInfo.Bundle, name+"-base.zip")
  }
  if commonInfo, ok := android.OtherModuleProvider(ctx, app, android.CommonModuleInfoProvider); ok && commonInfo.InstallFiles != nil {
   info := commonInfo.InstallFiles
   for _, file := range info.InstallFiles {
    // The "apex" partition is a fake partition just to create files in
    // out/target/product/<device>/apex. Including it leads to duplicate rule errors as
    // there are multiple apexes with files installed at the same location within them.
    if file.Partition() == "apex" {
     continue
    }

    ctx.DistForGoal("apps_only", file)
   }
   if len(info.InstallFiles) == 0 {
    outputFiles, err := android.OutputFilesForModuleOrErr(ctx, app, "")
    // OutputFilesForModuleOrErr can error out when the module doesn't provide any
    // output files. We don't care about that, just dist files when they're provided.
    if err == nil {
     for _, file := range outputFiles {
      ctx.DistForGoal("apps_only", file)
     }
    }
    if aarInfo, ok := android.OtherModuleProvider(ctx, app, java.AARProvider); ok {
     ctx.DistForGoal("apps_only", aarInfo.Aar)
    }
   }
  }
 }

 // Dist apexkeys.txt
 apexKeysFile := android.PathForModuleOut(ctx, "apexkeys.txt")
 apexKeysRuleBuilder := android.NewRuleBuilder(pctx, ctx).SandboxDisabled()
 apexKeysRuleBuilder.Command().Textf("rm -f %s && touch ", apexKeysFile.String()).Output(apexKeysFile)
 for _, app := range appModules {
  if info, ok := android.OtherModuleProvider(ctx, app, filesystem.ApexKeyPathInfoProvider); ok {
   apexKeysRuleBuilder.Command().Text("cat ").Input(info.ApexKeyPath).Text(" >> ").Output(apexKeysFile)
  }
 }
 apexKeysRuleBuilder.Build("unbundled_apexkeys.txt", "Unbundled apexkeys.txt")
 ctx.DistForGoal("apps_only", apexKeysFile)
 ctx.Phony("apexkeys.txt", apexKeysFile)

 // Dist symbols.zip
 if ctx.Config().IsEnvTrue("GROUP_ARTIFACTS_BY_MODULE") {
  for _, module := range appModules {
   groupName := fmt.Sprintf("%s-", android.OtherModuleNameWithPossibleOverride(ctx, module))
   symbolsZip := android.PathForOutput(ctx, "unbundled_singleton", targetProductPrefix+groupName+"symbols.zip")
   symbolsMapping := android.PathForOutput(ctx, "unbundled_singleton", targetProductPrefix+groupName+"symbols-mapping.textproto")
   android.BuildSymbolsZip(ctx, []android.ModuleProxy{module}, nil, symbolsZip, symbolsMapping)
   ctx.DistForGoalWithFilenameTag("apps_only", symbolsZip, symbolsZip.Base())
   ctx.DistForGoalWithFilenameTag("apps_only", symbolsMapping, symbolsMapping.Base())
  }
 } else {
  symbolsZip := android.PathForOutput(ctx, "unbundled_singleton", targetProductPrefix+"symbols.zip")
  symbolsMapping := android.PathForOutput(ctx, "unbundled_singleton", targetProductPrefix+"symbols-mapping.textproto")
  android.BuildSymbolsZip(ctx, appModules, nil, symbolsZip, symbolsMapping)
  ctx.DistForGoalWithFilenameTag("apps_only", symbolsZip, symbolsZip.Base())
  ctx.DistForGoalWithFilenameTag("apps_only", symbolsMapping, symbolsMapping.Base())
 }

 // Dist lint reports
 var reportFiles android.Paths
 for _, app := range appModules {
  name := android.OtherModuleNameWithPossibleOverride(ctx, app)
  if info, ok := android.OtherModuleProvider(ctx, app, java.ModuleLintReportZipsProvider); ok {
   reports := info.AllReports()
   for _, report := range reports {
    ctx.DistForGoalWithFilename("lint-check", report, fmt.Sprintf("%s-%s", name, report.Base()))
   }
   reportFiles = append(reportFiles, reports...)
  }
 }
 ctx.Phony("lint-check", reportFiles...)

 // Dist proguard zips
 proguardZips := java.BuildProguardZips(ctx, appModules)
 ctx.DistForGoalWithFilenameTag("apps_only", proguardZips.DictZip, targetProductPrefix+proguardZips.DictZip.Base())
 ctx.DistForGoalWithFilenameTag("apps_only", proguardZips.DictMapping, targetProductPrefix+proguardZips.DictMapping.Base())
 ctx.DistForGoalWithFilenameTag("apps_only", proguardZips.UsageZip, targetProductPrefix+proguardZips.UsageZip.Base())

 // Dist jacoco report jar
 if ctx.Config().IsEnvTrue("EMMA_INSTRUMENT") {
  if ctx.Config().IsEnvTrue("GROUP_ARTIFACTS_BY_MODULE") {
   for _, module := range appModules {
    jacocoZip := android.PathForModuleOut(ctx, fmt.Sprintf("%s-jacoco.jar", android.OtherModuleNameWithPossibleOverride(ctx, module)))
    java.BuildJacocoZipWithPotentialDeviceTests(ctx, []android.ModuleProxy{module}, jacocoZip)
    ctx.DistForGoal("apps_only", jacocoZip)
   }
  } else {
   jacocoZip := android.PathForModuleOut(ctx, "jacoco-report-classes-all.jar")
   java.BuildJacocoZipWithPotentialDeviceTests(ctx, appModules, jacocoZip)
   ctx.DistForGoal("apps_only", jacocoZip)
  }
 }

 // Dist sboms
 for _, app := range appModules {
  android.BuildUnbundledSbom(ctx, app)
 }

 ctx.DistForGoal("apps_only", java.ApkCertsFile(ctx))
}