services/core/java/com/android/server/pm/parsing/pkg/AndroidPackageUtils.java

   1 /*
   2  * Copyright (C) 2020 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package com.android.server.pm.parsing.pkg;
  18
  19 import android.annotation.NonNull;
  20 import android.annotation.Nullable;
  21 import android.content.pm.ApplicationInfo;
  22 import android.content.pm.PackageInfo;
  23 import android.content.pm.PackageManager;
  24 import android.content.pm.PackageParser;
  25 import android.content.pm.PackageParser.PackageParserException;
  26 import android.content.pm.SharedLibraryInfo;
  27 import android.content.pm.VersionedPackage;
  28 import android.content.pm.dex.DexMetadataHelper;
  29 import android.content.pm.parsing.ParsingPackageRead;
  30 import android.content.pm.parsing.component.ParsedActivity;
  31 import android.content.pm.parsing.component.ParsedInstrumentation;
  32 import android.content.pm.parsing.component.ParsedProvider;
  33 import android.content.pm.parsing.component.ParsedService;
  34 import android.os.incremental.IncrementalManager;
  35 import android.text.TextUtils;
  36
  37 import com.android.internal.content.NativeLibraryHelper;
  38 import com.android.internal.util.ArrayUtils;
  39 import com.android.server.SystemConfig;
  40 import com.android.server.pm.PackageSetting;
  41
  42 import java.io.IOException;
  43 import java.util.ArrayList;
  44 import java.util.Collection;
  45 import java.util.Collections;
  46 import java.util.List;
  47 import java.util.Map;
  48 import java.util.Objects;
  49
  50 /** @hide */
  51 public class AndroidPackageUtils {
  52
  53     private AndroidPackageUtils() {
  54     }
  55
  56     public static List<String> getAllCodePathsExcludingResourceOnly(
  57             AndroidPackage aPkg) {
  58         PackageImpl pkg = (PackageImpl) aPkg;
  59         ArrayList<String> paths = new ArrayList<>();
  60         if (pkg.isHasCode()) {
  61             paths.add(pkg.getBaseCodePath());
  62         }
  63         String[] splitCodePaths = pkg.getSplitCodePaths();
  64         if (!ArrayUtils.isEmpty(splitCodePaths)) {
  65             for (int i = 0; i < splitCodePaths.length; i++) {
  66                 if ((pkg.getSplitFlags()[i] & ApplicationInfo.FLAG_HAS_CODE) != 0) {
  67                     paths.add(splitCodePaths[i]);
  68                 }
  69             }
  70         }
  71         return paths;
  72     }
  73
  74     /**
  75      * @return a list of the base and split code paths.
  76      */
  77     public static List<String> getAllCodePaths(AndroidPackage aPkg) {
  78         PackageImpl pkg = (PackageImpl) aPkg;
  79         ArrayList<String> paths = new ArrayList<>();
  80         paths.add(pkg.getBaseCodePath());
  81
  82         String[] splitCodePaths = pkg.getSplitCodePaths();
  83         if (!ArrayUtils.isEmpty(splitCodePaths)) {
  84             Collections.addAll(paths, splitCodePaths);
  85         }
  86         return paths;
  87     }
  88
  89     public static SharedLibraryInfo createSharedLibraryForStatic(AndroidPackage pkg) {
  90         return new SharedLibraryInfo(null, pkg.getPackageName(),
  91                 AndroidPackageUtils.getAllCodePaths(pkg),
  92                 pkg.getStaticSharedLibName(),
  93                 pkg.getStaticSharedLibVersion(),
  94                 SharedLibraryInfo.TYPE_STATIC,
  95                 new VersionedPackage(pkg.getManifestPackageName(),
  96                         pkg.getLongVersionCode()),
  97                 null, null);
  98     }
  99
 100     public static SharedLibraryInfo createSharedLibraryForDynamic(AndroidPackage pkg, String name) {
 101         return new SharedLibraryInfo(null, pkg.getPackageName(),
 102                 AndroidPackageUtils.getAllCodePaths(pkg), name,
 103                 SharedLibraryInfo.VERSION_UNDEFINED,
 104                 SharedLibraryInfo.TYPE_DYNAMIC, new VersionedPackage(pkg.getPackageName(),
 105                 pkg.getLongVersionCode()),
 106                 null, null);
 107     }
 108
 109     /**
 110      * Return the dex metadata files for the given package as a map
 111      * [code path -> dex metadata path].
 112      *
 113      * NOTE: involves I/O checks.
 114      */
 115     public static Map<String, String> getPackageDexMetadata(AndroidPackage pkg) {
 116         return DexMetadataHelper.buildPackageApkToDexMetadataMap
 117                 (AndroidPackageUtils.getAllCodePaths(pkg));
 118     }
 119
 120     /**
 121      * Validate the dex metadata files installed for the given package.
 122      *
 123      * @throws PackageParserException in case of errors.
 124      */
 125     public static void validatePackageDexMetadata(AndroidPackage pkg)
 126             throws PackageParserException {
 127         Collection<String> apkToDexMetadataList = getPackageDexMetadata(pkg).values();
 128         for (String dexMetadata : apkToDexMetadataList) {
 129             DexMetadataHelper.validateDexMetadataFile(dexMetadata);
 130         }
 131     }
 132
 133     public static NativeLibraryHelper.Handle createNativeLibraryHandle(AndroidPackage pkg)
 134             throws IOException {
 135         return NativeLibraryHelper.Handle.create(
 136                 AndroidPackageUtils.getAllCodePaths(pkg),
 137                 pkg.isMultiArch(),
 138                 pkg.isExtractNativeLibs(),
 139                 pkg.isDebuggable(),
 140                 pkg.getPackageName()
 141         );
 142     }
 143
 144     public static boolean canHaveOatDir(AndroidPackage pkg, boolean isUpdatedSystemApp) {
 145         // The following app types CANNOT have oat directory
 146         // - non-updated system apps,
 147         // - incrementally installed apps.
 148         if (pkg.isSystem() && !isUpdatedSystemApp) {
 149             return false;
 150         }
 151         if (IncrementalManager.isIncrementalPath(pkg.getCodePath())) {
 152             return false;
 153         }
 154         return true;
 155     }
 156
 157     public static boolean hasComponentClassName(AndroidPackage pkg, String className) {
 158         List<ParsedActivity> activities = pkg.getActivities();
 159         int activitiesSize = activities.size();
 160         for (int index = 0; index < activitiesSize; index++) {
 161             if (Objects.equals(className, activities.get(index).getName())) {
 162                 return true;
 163             }
 164         }
 165
 166         List<ParsedActivity> receivers = pkg.getReceivers();
 167         int receiversSize = receivers.size();
 168         for (int index = 0; index < receiversSize; index++) {
 169             if (Objects.equals(className, receivers.get(index).getName())) {
 170                 return true;
 171             }
 172         }
 173
 174         List<ParsedProvider> providers = pkg.getProviders();
 175         int providersSize = providers.size();
 176         for (int index = 0; index < providersSize; index++) {
 177             if (Objects.equals(className, providers.get(index).getName())) {
 178                 return true;
 179             }
 180         }
 181
 182         List<ParsedService> services = pkg.getServices();
 183         int servicesSize = services.size();
 184         for (int index = 0; index < servicesSize; index++) {
 185             if (Objects.equals(className, services.get(index).getName())) {
 186                 return true;
 187             }
 188         }
 189
 190         List<ParsedInstrumentation> instrumentations = pkg.getInstrumentations();
 191         int instrumentationsSize = instrumentations.size();
 192         for (int index = 0; index < instrumentationsSize; index++) {
 193             if (Objects.equals(className, instrumentations.get(index).getName())) {
 194                 return true;
 195             }
 196         }
 197
 198         return false;
 199     }
 200
 201     public static boolean isEncryptionAware(AndroidPackage pkg) {
 202         return pkg.isDirectBootAware() || pkg.isPartiallyDirectBootAware();
 203     }
 204
 205     public static boolean isLibrary(AndroidPackage pkg) {
 206         // TODO(b/135203078): Can parsing just enforce these always match?
 207         return pkg.getStaticSharedLibName() != null || !pkg.getLibraryNames().isEmpty();
 208     }
 209
 210     public static int getHiddenApiEnforcementPolicy(AndroidPackage pkg,
 211             @NonNull PackageSetting pkgSetting) {
 212         boolean isAllowedToUseHiddenApis;
 213         if (pkg.isSignedWithPlatformKey()) {
 214             isAllowedToUseHiddenApis = true;
 215         } else if (pkg.isSystem() || pkgSetting.getPkgState().isUpdatedSystemApp()) {
 216             isAllowedToUseHiddenApis = pkg.isUsesNonSdkApi()
 217                     || SystemConfig.getInstance().getHiddenApiWhitelistedApps().contains(
 218                     pkg.getPackageName());
 219         } else {
 220             isAllowedToUseHiddenApis = false;
 221         }
 222
 223         if (isAllowedToUseHiddenApis) {
 224             return ApplicationInfo.HIDDEN_API_ENFORCEMENT_DISABLED;
 225         }
 226
 227         // TODO(b/135203078): Handle maybeUpdateHiddenApiEnforcementPolicy. Right now it's done
 228         //  entirely through ApplicationInfo and shouldn't touch this specific class, but that
 229         //  may not always hold true.
 230 //        if (mHiddenApiPolicy != ApplicationInfo.HIDDEN_API_ENFORCEMENT_DEFAULT) {
 231 //            return mHiddenApiPolicy;
 232 //        }
 233         return ApplicationInfo.HIDDEN_API_ENFORCEMENT_ENABLED;
 234     }
 235
 236     public static int getIcon(ParsingPackageRead pkg) {
 237         return (PackageParser.sUseRoundIcon && pkg.getRoundIconRes() != 0)
 238                 ? pkg.getRoundIconRes() : pkg.getIconRes();
 239     }
 240
 241     public static long getLongVersionCode(AndroidPackage pkg) {
 242         return PackageInfo.composeLongVersionCode(pkg.getVersionCodeMajor(), pkg.getVersionCode());
 243     }
 244
 245     /**
 246      * Returns false iff the provided flags include the {@link PackageManager#MATCH_SYSTEM_ONLY}
 247      * flag and the provided package is not a system package. Otherwise returns {@code true}.
 248      */
 249     public static boolean isMatchForSystemOnly(AndroidPackage pkg, int flags) {
 250         if ((flags & PackageManager.MATCH_SYSTEM_ONLY) != 0) {
 251             return pkg.isSystem();
 252         }
 253         return true;
 254     }
 255
 256     public static String getPrimaryCpuAbi(AndroidPackage pkg, @Nullable PackageSetting pkgSetting) {
 257         if (pkgSetting == null || TextUtils.isEmpty(pkgSetting.primaryCpuAbiString)) {
 258             return pkg.getPrimaryCpuAbi();
 259         }
 260
 261         return pkgSetting.primaryCpuAbiString;
 262     }
 263
 264     public static String getSecondaryCpuAbi(AndroidPackage pkg,
 265             @Nullable PackageSetting pkgSetting) {
 266         if (pkgSetting == null || TextUtils.isEmpty(pkgSetting.secondaryCpuAbiString)) {
 267             return pkg.getSecondaryCpuAbi();
 268         }
 269
 270         return pkgSetting.secondaryCpuAbiString;
 271     }
 272
 273     /**
 274      * Returns the primary ABI as parsed from the package. Used only during parsing and derivation.
 275      * Otherwise prefer {@link #getPrimaryCpuAbi(AndroidPackage, PackageSetting)}.
 276      *
 277      * TODO(b/135203078): Actually hide the method
 278      * Placed in the utility to hide the method on the interface.
 279      */
 280     public static String getRawPrimaryCpuAbi(AndroidPackage pkg) {
 281         return pkg.getPrimaryCpuAbi();
 282     }
 283
 284     /**
 285      * Returns the secondary ABI as parsed from the package. Used only during parsing and
 286      * derivation. Otherwise prefer {@link #getSecondaryCpuAbi(AndroidPackage, PackageSetting)}.
 287      *
 288      * TODO(b/135203078): Actually hide the method
 289      * Placed in the utility to hide the method on the interface.
 290      */
 291     public static String getRawSecondaryCpuAbi(AndroidPackage pkg) {
 292         return pkg.getSecondaryCpuAbi();
 293     }
 294
 295     public static String getSeInfo(AndroidPackage pkg, @Nullable PackageSetting pkgSetting) {
 296         if (pkgSetting != null) {
 297             String overrideSeInfo = pkgSetting.getPkgState().getOverrideSeInfo();
 298             if (!TextUtils.isEmpty(overrideSeInfo)) {
 299                 return overrideSeInfo;
 300             }
 301         }
 302         return pkg.getSeInfo();
 303     }
 304 }