Quelle  app_set.go   Sprache: Unknown

// Copyright 2020 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

// This file contains the module implementation for android_app_set.

import (
 "strconv"
 "strings"

 "github.com/google/blueprint/proptools"

 "android/soong/android"
)

func init() {
 RegisterAppSetBuildComponents(android.InitRegistrationContext)
}

func RegisterAppSetBuildComponents(ctx android.RegistrationContext) {
 ctx.RegisterModuleType("android_app_set", AndroidAppSetFactory)
}

type AndroidAppSetProperties struct {
 // APK Set path
 Set *string `android:"path"`

 // Specifies that this app should be installed to the priv-app directory,
 // where the system will grant it additional privileges not available to
 // normal apps.
 Privileged *bool

 // APKs in this set use prerelease SDK version
 Prerelease *bool

 // Names of modules to be overridden. Listed modules can only be other apps
 // (in Make or Soong).
 Overrides []string

 // Path to the .prebuilt_info file of the prebuilt app.
 // In case of mainline modules, the .prebuilt_info file contains the build_id that was used
 // to generate the prebuilt.
 Prebuilt_info *string `android:"path"`
}

type AndroidAppSet struct {
 android.ModuleBase
 android.DefaultableModuleBase
 prebuilt android.Prebuilt

 properties    AndroidAppSetProperties
 packedOutput  android.WritablePath
 primaryOutput android.WritablePath
 apkcertsFile  android.ModuleOutPath
}

func (as *AndroidAppSet) Name() string {
 return as.prebuilt.Name(as.ModuleBase.Name())
}

func (as *AndroidAppSet) IsInstallable() bool {
 return true
}

func (as *AndroidAppSet) Prebuilt() *android.Prebuilt {
 return &as.prebuilt
}

func (as *AndroidAppSet) Privileged() bool {
 return Bool(as.properties.Privileged)
}

func (as *AndroidAppSet) OutputFile() android.Path {
 return as.primaryOutput
}

func (as *AndroidAppSet) PackedAdditionalOutputs() android.Path {
 return as.packedOutput
}

func (as *AndroidAppSet) APKCertsFile() android.Path {
 return as.apkcertsFile
}

var TargetCpuAbi = map[string]string{
 "arm":   "ARMEABI_V7A",
 "arm64": "ARM64_V8A",
 // TODO: use "RISCV64" when that is supported in bundles
 "riscv64": "ARM64_V8A",
 "x86":     "X86",
 "x86_64":  "X86_64",
}

func SupportedAbis(ctx android.ModuleContext, excludeNativeBridgeAbis bool) []string {
 abiName := func(targetIdx int, deviceArch string) string {
  if abi, found := TargetCpuAbi[deviceArch]; found {
   return abi
  }
  ctx.ModuleErrorf("Target %d has invalid Arch: %s", targetIdx, deviceArch)
  return "BAD_ABI"
 }

 var result []string
 for i, target := range ctx.Config().Targets[android.Android] {
  if target.NativeBridge == android.NativeBridgeEnabled && excludeNativeBridgeAbis {
   continue
  }
  result = append(result, abiName(i, target.Arch.ArchType.String()))
 }
 return result
}

type prebuiltInfoProps struct {
 baseModuleName string
 isPrebuilt     bool
 prebuiltInfo   *string
}

// Set prebuiltInfoProvider. This will be used by `apex_prebuiltinfo_singleton` to print out a metadata file
// with information about whether source or prebuilt of an apex was used during the build.
func providePrebuiltInfo(ctx android.ModuleContext, p prebuiltInfoProps) {
 info := android.PrebuiltJsonInfo{
  Name:        p.baseModuleName,
  Is_prebuilt: p.isPrebuilt,
 }
 // If Prebuilt_info information is available in the soong module definition, add it to prebuilt_info.json.
 if p.prebuiltInfo != nil {
  prebuiltInfoFile := android.PathForModuleSrc(ctx, *p.prebuiltInfo)
  info.Prebuilt_info_file_path = prebuiltInfoFile.String()
 }
 android.SetProvider(ctx, android.PrebuiltJsonInfoProvider, info)
}

func (as *AndroidAppSet) GenerateAndroidBuildActions(ctx android.ModuleContext) {
 as.packedOutput = android.PathForModuleOut(ctx, ctx.ModuleName()+".zip")
 as.primaryOutput = android.PathForModuleOut(ctx, as.BaseModuleName()+".apk")
 as.apkcertsFile = android.PathForModuleOut(ctx, "apkcerts.txt")
 // We are assuming here that the install file in the APK
 // set has `.apk` suffix. If it doesn't the build will fail.
 // APK sets containing APEX files are handled elsewhere.
 screenDensities := "all"
 if dpis := ctx.Config().ProductAAPTPrebuiltDPI(); len(dpis) > 0 {
  screenDensities = strings.ToUpper(strings.Join(dpis, ","))
 }
 // TODO(asmundak): handle locales.
 // TODO(asmundak): do we support device features
 ctx.Build(pctx,
  android.BuildParams{
   Rule:            extractMatchingApks,
   Description:     "Extract APKs from APK set",
   Output:          as.primaryOutput,
   ImplicitOutputs: android.WritablePaths{as.packedOutput, as.apkcertsFile},
   Inputs:          android.Paths{as.prebuilt.SingleSourcePath(ctx)},
   Args: map[string]string{
    "abis":              strings.Join(SupportedAbis(ctx, false), ","),
    "allow-prereleased": strconv.FormatBool(proptools.Bool(as.properties.Prerelease)),
    "screen-densities":  screenDensities,
    "sdk-version":       ctx.Config().PlatformSdkVersion().String(),
    "skip-sdk-check":    strconv.FormatBool(ctx.Config().IsEnvTrue("SOONG_SKIP_APPSET_SDK_CHECK")),
    "stem":              as.BaseModuleName(),
    "apkcerts":          as.apkcertsFile.String(),
    "partition":         as.PartitionTag(ctx.DeviceConfig()),
    "zip":               as.packedOutput.String(),
   },
  })

 var installDir android.InstallPath
 if as.Privileged() {
  installDir = android.PathForModuleInstall(ctx, "priv-app", as.BaseModuleName())
 } else {
  installDir = android.PathForModuleInstall(ctx, "app", as.BaseModuleName())
 }
 ctx.InstallFileWithExtraFilesZip(installDir, as.BaseModuleName()+".apk", as.primaryOutput, as.packedOutput)

 providePrebuiltInfo(ctx,
  prebuiltInfoProps{
   baseModuleName: as.BaseModuleName(),
   isPrebuilt:     true,
   prebuiltInfo:   as.properties.Prebuilt_info,
  },
 )

 android.SetProvider(ctx, AppInfoProvider, &AppInfo{
  AppSet:                  true,
  Privileged:              as.Privileged(),
  OutputFile:              as.OutputFile(),
  ApkCertsFile:            as.apkcertsFile,
  PackedAdditionalOutputs: as.packedOutput,
 })
 android.SetProvider(ctx, ApkCertInfoProvider, ApkCertInfo{
  ApkCertsFile: as.apkcertsFile,
 })
}

func (as *AndroidAppSet) InstallBypassMake() bool { return true }

// android_app_set extracts a set of APKs based on the target device
// configuration and installs this set as "split APKs".
// The extracted set always contains an APK whose name is
// _module_name_.apk and every split APK matching target device.
// The extraction of the density-specific splits depends on
// PRODUCT_AAPT_PREBUILT_DPI variable. If present (its value should
// be a list density names: LDPI, MDPI, HDPI, etc.), only listed
// splits will be extracted. Otherwise all density-specific splits
// will be extracted.
func AndroidAppSetFactory() android.Module {
 module := &AndroidAppSet{}
 module.AddProperties(&module.properties)
 InitJavaModule(module, android.DeviceSupported)
 android.InitSingleSourcePrebuiltModule(module, &module.properties, "Set")
 return module
}