| package org.robolectric.shadows; |
| |
| import static android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_DISABLED; |
| import static android.content.pm.PackageManager.GET_ACTIVITIES; |
| import static android.content.pm.PackageManager.GET_CONFIGURATIONS; |
| import static android.content.pm.PackageManager.GET_GIDS; |
| import static android.content.pm.PackageManager.GET_INSTRUMENTATION; |
| import static android.content.pm.PackageManager.GET_INTENT_FILTERS; |
| import static android.content.pm.PackageManager.GET_META_DATA; |
| import static android.content.pm.PackageManager.GET_PERMISSIONS; |
| import static android.content.pm.PackageManager.GET_PROVIDERS; |
| import static android.content.pm.PackageManager.GET_RECEIVERS; |
| import static android.content.pm.PackageManager.GET_RESOLVED_FILTER; |
| import static android.content.pm.PackageManager.GET_SERVICES; |
| import static android.content.pm.PackageManager.GET_SHARED_LIBRARY_FILES; |
| import static android.content.pm.PackageManager.GET_SIGNATURES; |
| import static android.content.pm.PackageManager.GET_URI_PERMISSION_PATTERNS; |
| import static android.content.pm.PackageManager.MATCH_DIRECT_BOOT_AWARE; |
| import static android.content.pm.PackageManager.MATCH_DIRECT_BOOT_UNAWARE; |
| import static android.content.pm.PackageManager.MATCH_DISABLED_COMPONENTS; |
| import static android.content.pm.PackageManager.MATCH_DISABLED_UNTIL_USED_COMPONENTS; |
| import static android.content.pm.PackageManager.MATCH_UNINSTALLED_PACKAGES; |
| import static android.content.pm.PackageManager.SIGNATURE_FIRST_NOT_SIGNED; |
| import static android.content.pm.PackageManager.SIGNATURE_MATCH; |
| import static android.content.pm.PackageManager.SIGNATURE_NEITHER_SIGNED; |
| import static android.content.pm.PackageManager.SIGNATURE_NO_MATCH; |
| import static android.content.pm.PackageManager.SIGNATURE_SECOND_NOT_SIGNED; |
| import static android.os.Build.VERSION_CODES.JELLY_BEAN_MR1; |
| import static android.os.Build.VERSION_CODES.KITKAT; |
| import static android.os.Build.VERSION_CODES.LOLLIPOP_MR1; |
| import static android.os.Build.VERSION_CODES.M; |
| import static android.os.Build.VERSION_CODES.N; |
| import static java.util.Arrays.asList; |
| |
| import android.Manifest; |
| import android.annotation.Nullable; |
| import android.annotation.UserIdInt; |
| import android.content.ComponentName; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.content.IntentFilter; |
| import android.content.IntentFilter.AuthorityEntry; |
| import android.content.IntentSender; |
| import android.content.pm.ApplicationInfo; |
| import android.content.pm.ComponentInfo; |
| import android.content.pm.FeatureInfo; |
| import android.content.pm.IPackageDataObserver; |
| import android.content.pm.IPackageDeleteObserver; |
| import android.content.pm.PackageInfo; |
| import android.content.pm.PackageManager; |
| import android.content.pm.PackageManager.NameNotFoundException; |
| import android.content.pm.PackageParser; |
| import android.content.pm.PackageParser.Component; |
| import android.content.pm.PackageParser.Package; |
| import android.content.pm.PackageStats; |
| import android.content.pm.PackageUserState; |
| import android.content.pm.PermissionGroupInfo; |
| import android.content.pm.PermissionInfo; |
| import android.content.pm.ResolveInfo; |
| import android.content.pm.Signature; |
| import android.content.res.Resources; |
| import android.graphics.drawable.Drawable; |
| import android.net.Uri; |
| import android.os.Binder; |
| import android.os.Build; |
| import android.os.Build.VERSION; |
| import android.os.PatternMatcher; |
| import android.os.PersistableBundle; |
| import android.os.Process; |
| import android.os.RemoteException; |
| import android.os.UserHandle; |
| import android.util.ArraySet; |
| import android.util.Pair; |
| import com.google.common.base.Preconditions; |
| import com.google.common.collect.HashMultimap; |
| import com.google.common.collect.Multimap; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collections; |
| import java.util.Comparator; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.LinkedHashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Objects; |
| import java.util.Set; |
| import java.util.TreeMap; |
| import org.robolectric.RuntimeEnvironment; |
| import org.robolectric.annotation.Implementation; |
| import org.robolectric.annotation.Implements; |
| import org.robolectric.annotation.Resetter; |
| import org.robolectric.util.ReflectionHelpers; |
| import org.robolectric.util.TempDirectory; |
| |
| @Implements(PackageManager.class) |
| public class ShadowPackageManager { |
| |
| static Map<String, Boolean> permissionRationaleMap = new HashMap<>(); |
| static List<FeatureInfo> systemAvailableFeatures = new ArrayList<>(); |
| static final List<String> systemSharedLibraryNames = new ArrayList<>(); |
| static final Map<String, PackageInfo> packageInfos = new LinkedHashMap<>(); |
| static final Map<String, Package> packages = new LinkedHashMap<>(); |
| private static Map<String, PackageInfo> packageArchiveInfo = new HashMap<>(); |
| static final Map<String, PackageStats> packageStatsMap = new HashMap<>(); |
| static final Map<String, String> packageInstallerMap = new HashMap<>(); |
| static final Map<Integer, String[]> packagesForUid = new HashMap<>(); |
| static final Map<String, Integer> uidForPackage = new HashMap<>(); |
| static final Map<Integer, List<String>> packagesForUserId = new HashMap<>(); |
| static final Map<Integer, String> namesForUid = new HashMap<>(); |
| static final Map<Integer, Integer> verificationResults = new HashMap<>(); |
| static final Map<Integer, Long> verificationTimeoutExtension = new HashMap<>(); |
| static final Map<String, String> currentToCanonicalNames = new HashMap<>(); |
| static final Map<ComponentName, ComponentState> componentList = new LinkedHashMap<>(); |
| static final Map<ComponentName, Drawable> drawableList = new LinkedHashMap<>(); |
| static final Map<String, Drawable> applicationIcons = new HashMap<>(); |
| static final Map<String, Drawable> unbadgedApplicationIcons = new HashMap<>(); |
| static final Map<String, Boolean> systemFeatureList = new LinkedHashMap<>(); |
| static final Map<IntentFilterWrapper, ComponentName> preferredActivities = new LinkedHashMap<>(); |
| static final Map<Pair<String, Integer>, Drawable> drawables = new LinkedHashMap<>(); |
| static final Map<String, Integer> applicationEnabledSettingMap = new HashMap<>(); |
| static Map<String, PermissionInfo> extraPermissions = new HashMap<>(); |
| static Map<String, PermissionGroupInfo> extraPermissionGroups = new HashMap<>(); |
| public static Map<String, Resources> resources = new HashMap<>(); |
| private static final Map<Intent, List<ResolveInfo>> resolveInfoForIntent = |
| new TreeMap<>(new IntentComparator()); |
| private static Set<String> deletedPackages = new HashSet<>(); |
| static Map<String, IPackageDeleteObserver> pendingDeleteCallbacks = new HashMap<>(); |
| static Set<String> hiddenPackages = new HashSet<>(); |
| static Multimap<Integer, String> sequenceNumberChangedPackagesMap = HashMultimap.create(); |
| static boolean canRequestPackageInstalls = false; |
| |
| /** |
| * Settings for a particular package. |
| * |
| * <p>This class mirrors {@link com.android.server.pm.PackageSetting}, which is used by {@link |
| * PackageManager}. |
| */ |
| public static class PackageSetting { |
| |
| /** Whether the package is suspended in {@link PackageManager}. */ |
| private boolean suspended = false; |
| |
| /** The message to be displayed to the user when they try to launch the app. */ |
| private String dialogMessage = null; |
| |
| /** An optional {@link PersistableBundle} shared with the app. */ |
| private PersistableBundle suspendedAppExtras = null; |
| |
| /** An optional {@link PersistableBundle} shared with the launcher. */ |
| private PersistableBundle suspendedLauncherExtras = null; |
| |
| public PackageSetting() {} |
| |
| public PackageSetting(PackageSetting that) { |
| this.suspended = that.suspended; |
| this.dialogMessage = that.dialogMessage; |
| this.suspendedAppExtras = deepCopyNullablePersistableBundle(that.suspendedAppExtras); |
| this.suspendedLauncherExtras = |
| deepCopyNullablePersistableBundle(that.suspendedLauncherExtras); |
| } |
| |
| /** |
| * Sets the suspension state of the package. |
| * |
| * <p>If {@code suspended} is false, {@code dialogMessage}, {@code appExtras}, and {@code |
| * launcherExtras} will be ignored. |
| */ |
| void setSuspended( |
| boolean suspended, |
| String dialogMessage, |
| PersistableBundle appExtras, |
| PersistableBundle launcherExtras) { |
| this.suspended = suspended; |
| this.dialogMessage = suspended ? dialogMessage : null; |
| this.suspendedAppExtras = suspended ? deepCopyNullablePersistableBundle(appExtras) : null; |
| this.suspendedLauncherExtras = |
| suspended ? deepCopyNullablePersistableBundle(launcherExtras) : null; |
| } |
| |
| public boolean isSuspended() { |
| return suspended; |
| } |
| |
| public String getDialogMessage() { |
| return dialogMessage; |
| } |
| |
| public PersistableBundle getSuspendedAppExtras() { |
| return suspendedAppExtras; |
| } |
| |
| public PersistableBundle getSuspendedLauncherExtras() { |
| return suspendedLauncherExtras; |
| } |
| |
| private static PersistableBundle deepCopyNullablePersistableBundle(PersistableBundle bundle) { |
| return bundle == null ? null : bundle.deepCopy(); |
| } |
| } |
| |
| static final Map<String, PackageSetting> packageSettings = new HashMap<>(); |
| |
| // From com.android.server.pm.PackageManagerService.compareSignatures(). |
| static int compareSignature(Signature[] signatures1, Signature[] signatures2) { |
| if (signatures1 == null) { |
| return (signatures2 == null) ? SIGNATURE_NEITHER_SIGNED : SIGNATURE_FIRST_NOT_SIGNED; |
| } |
| if (signatures2 == null) { |
| return SIGNATURE_SECOND_NOT_SIGNED; |
| } |
| if (signatures1.length != signatures2.length) { |
| return SIGNATURE_NO_MATCH; |
| } |
| HashSet<Signature> signatures1set = new HashSet<>(asList(signatures1)); |
| HashSet<Signature> signatures2set = new HashSet<>(asList(signatures2)); |
| return signatures1set.equals(signatures2set) ? SIGNATURE_MATCH : SIGNATURE_NO_MATCH; |
| } |
| |
| static String resolvePackageName(String packageName, ComponentName componentName) { |
| String classString = componentName.getClassName(); |
| int index = classString.indexOf('.'); |
| if (index == -1) { |
| classString = packageName + "." + classString; |
| } else if (index == 0) { |
| classString = packageName + classString; |
| } |
| return classString; |
| } |
| |
| // TODO(christianw): reconcile with ParallelUniverse.setUpPackageStorage |
| private static void setUpPackageStorage(ApplicationInfo applicationInfo) { |
| TempDirectory tempDirectory = RuntimeEnvironment.getTempDirectory(); |
| |
| if (applicationInfo.sourceDir == null) { |
| applicationInfo.sourceDir = |
| tempDirectory |
| .createIfNotExists(applicationInfo.packageName + "-sourceDir") |
| .toAbsolutePath() |
| .toString(); |
| } |
| |
| if (applicationInfo.dataDir == null) { |
| applicationInfo.dataDir = |
| tempDirectory |
| .createIfNotExists(applicationInfo.packageName + "-dataDir") |
| .toAbsolutePath() |
| .toString(); |
| } |
| if (applicationInfo.publicSourceDir == null) { |
| applicationInfo.publicSourceDir = applicationInfo.sourceDir; |
| } |
| if (RuntimeEnvironment.getApiLevel() >= N) { |
| applicationInfo.credentialProtectedDataDir = |
| tempDirectory.createIfNotExists("userDataDir").toAbsolutePath().toString(); |
| applicationInfo.deviceProtectedDataDir = |
| tempDirectory.createIfNotExists("deviceDataDir").toAbsolutePath().toString(); |
| } |
| } |
| |
| /** |
| * Sets extra resolve infos for an intent. |
| * |
| * <p>Those entries are added to whatever might be in the manifest already. |
| * |
| * <p>Note that all resolve infos will have {@link ResolveInfo#isDefault} field set to {@code |
| * true} to allow their resolution for implicit intents. If this is not what you want, then you |
| * still have the reference to those ResolveInfos, and you can set the field back to {@code |
| * false}. |
| */ |
| public void setResolveInfosForIntent(Intent intent, List<ResolveInfo> info) { |
| resolveInfoForIntent.remove(intent); |
| for (ResolveInfo resolveInfo : info) { |
| addResolveInfoForIntent(intent, resolveInfo); |
| } |
| } |
| |
| /** |
| * @deprecated please use {@link #setResolveInfosForIntent} or {@link |
| * #addResolveInfoForIntent(Intent, ResolveInfo)} instead. |
| */ |
| @Deprecated |
| public void addResolveInfoForIntent(Intent intent, List<ResolveInfo> info) { |
| setResolveInfosForIntent(intent, info); |
| } |
| |
| /** |
| * Adds extra resolve info for an intent. |
| * |
| * <p>Note that this resolve info will have {@link ResolveInfo#isDefault} field set to {@code |
| * true} to allow its resolution for implicit intents. If this is not what you want, then please |
| * use {@link #addResolveInfoForIntentNoDefaults} instead. |
| */ |
| public void addResolveInfoForIntent(Intent intent, ResolveInfo info) { |
| info.isDefault = true; |
| ComponentInfo[] componentInfos = |
| new ComponentInfo[] { |
| info.activityInfo, |
| info.serviceInfo, |
| Build.VERSION.SDK_INT >= KITKAT ? info.providerInfo : null |
| }; |
| for (ComponentInfo component : componentInfos) { |
| if (component != null && component.applicationInfo != null) { |
| component.applicationInfo.flags |= ApplicationInfo.FLAG_INSTALLED; |
| } |
| } |
| addResolveInfoForIntentNoDefaults(intent, info); |
| } |
| |
| /** |
| * Adds the {@code info} as {@link ResolveInfo} for the intent but without applying any default |
| * values. |
| * |
| * <p>In particular it will not make the {@link ResolveInfo#isDefault} field {@code true}, that |
| * means that this resolve info will not resolve for {@link Intent#resolveActivity} and {@link |
| * Context#startActivity}. |
| */ |
| public void addResolveInfoForIntentNoDefaults(Intent intent, ResolveInfo info) { |
| Preconditions.checkNotNull(info); |
| List<ResolveInfo> infoList = resolveInfoForIntent.get(intent); |
| if (infoList == null) { |
| infoList = new ArrayList<>(); |
| resolveInfoForIntent.put(intent, infoList); |
| } |
| infoList.add(info); |
| } |
| |
| public void removeResolveInfosForIntent(Intent intent, String packageName) { |
| List<ResolveInfo> infoList = resolveInfoForIntent.get(intent); |
| if (infoList == null) { |
| infoList = new ArrayList<>(); |
| resolveInfoForIntent.put(intent, infoList); |
| } |
| |
| for (Iterator<ResolveInfo> iterator = infoList.iterator(); iterator.hasNext(); ) { |
| ResolveInfo resolveInfo = iterator.next(); |
| if (getPackageName(resolveInfo).equals(packageName)) { |
| iterator.remove(); |
| } |
| } |
| } |
| |
| private static String getPackageName(ResolveInfo resolveInfo) { |
| if (resolveInfo.resolvePackageName != null) { |
| return resolveInfo.resolvePackageName; |
| } else if (resolveInfo.activityInfo != null) { |
| return resolveInfo.activityInfo.packageName; |
| } else if (resolveInfo.serviceInfo != null) { |
| return resolveInfo.serviceInfo.packageName; |
| } else if (resolveInfo.providerInfo != null) { |
| return resolveInfo.providerInfo.packageName; |
| } |
| throw new IllegalStateException( |
| "Could not find package name for ResolveInfo " + resolveInfo.toString()); |
| } |
| |
| public void addActivityIcon(ComponentName component, Drawable drawable) { |
| drawableList.put(component, drawable); |
| } |
| |
| public void addActivityIcon(Intent intent, Drawable drawable) { |
| drawableList.put(intent.getComponent(), drawable); |
| } |
| |
| public void setApplicationIcon(String packageName, Drawable drawable) { |
| applicationIcons.put(packageName, drawable); |
| } |
| |
| public void setUnbadgedApplicationIcon(String packageName, Drawable drawable) { |
| unbadgedApplicationIcons.put(packageName, drawable); |
| } |
| |
| /** |
| * Return the flags set in call to {@link |
| * android.app.ApplicationPackageManager#setComponentEnabledSetting(ComponentName, int, int)}. |
| * |
| * @param componentName The component name. |
| * @return The flags. |
| */ |
| public int getComponentEnabledSettingFlags(ComponentName componentName) { |
| ComponentState state = componentList.get(componentName); |
| return state != null ? state.flags : 0; |
| } |
| |
| /** |
| * Installs a package with the {@link PackageManager}. |
| * |
| * <p>In order to create PackageInfo objects in a valid state please use {@link |
| * androidx.test.core.content.pm.PackageInfoBuilder}. |
| * |
| * <p>This method automatically simulates instalation of a package in the system, so it adds a |
| * flag {@link ApplicationInfo#FLAG_INSTALLED} to the application info and makes sure it exits. It |
| * will update applicationInfo in package components as well. |
| * |
| * <p>If you don't want the package to be installed, use {@link #addPackageNoDefaults} instead. |
| */ |
| public void installPackage(PackageInfo packageInfo) { |
| ApplicationInfo appInfo = packageInfo.applicationInfo; |
| if (appInfo == null) { |
| appInfo = new ApplicationInfo(); |
| appInfo.packageName = packageInfo.packageName; |
| packageInfo.applicationInfo = appInfo; |
| } |
| appInfo.flags |= ApplicationInfo.FLAG_INSTALLED; |
| ComponentInfo[][] componentInfoArrays = |
| new ComponentInfo[][] { |
| packageInfo.activities, |
| packageInfo.services, |
| packageInfo.providers, |
| packageInfo.receivers, |
| }; |
| for (ComponentInfo[] componentInfos : componentInfoArrays) { |
| if (componentInfos == null) { |
| continue; |
| } |
| for (ComponentInfo componentInfo : componentInfos) { |
| if (componentInfo.applicationInfo == null) { |
| componentInfo.applicationInfo = appInfo; |
| } |
| componentInfo.applicationInfo.flags |= ApplicationInfo.FLAG_INSTALLED; |
| } |
| } |
| addPackageNoDefaults(packageInfo); |
| } |
| |
| /** |
| * Adds a package to the {@link PackageManager}, but doesn't set any default values on it. |
| * |
| * <p>Right now it will not set {@link ApplicationInfo#FLAG_INSTALLED} flag on its application, so |
| * if not set explicitly, it will be treated as not installed. |
| */ |
| public void addPackageNoDefaults(PackageInfo packageInfo) { |
| PackageStats packageStats = new PackageStats(packageInfo.packageName); |
| addPackage(packageInfo, packageStats); |
| } |
| |
| /** |
| * Installs a package with its stats with the {@link PackageManager}. |
| * |
| * <p>This method doesn't add any defaults to the {@code packageInfo} parameters. You should make |
| * sure it is valid (see {@link #installPackage(PackageInfo)}). |
| */ |
| public synchronized void addPackage(PackageInfo packageInfo, PackageStats packageStats) { |
| Preconditions.checkArgument(packageInfo.packageName.equals(packageStats.packageName)); |
| |
| packageInfos.put(packageInfo.packageName, packageInfo); |
| packageStatsMap.put(packageInfo.packageName, packageStats); |
| |
| packageSettings.put(packageInfo.packageName, new PackageSetting()); |
| |
| applicationEnabledSettingMap.put( |
| packageInfo.packageName, PackageManager.COMPONENT_ENABLED_STATE_DEFAULT); |
| if (packageInfo.applicationInfo != null) { |
| namesForUid.put(packageInfo.applicationInfo.uid, packageInfo.packageName); |
| } |
| } |
| |
| /** @deprecated Use {@link #installPackage(PackageInfo)} instead. */ |
| @Deprecated |
| public void addPackage(String packageName) { |
| PackageInfo packageInfo = new PackageInfo(); |
| packageInfo.packageName = packageName; |
| |
| ApplicationInfo applicationInfo = new ApplicationInfo(); |
| |
| applicationInfo.packageName = packageName; |
| // TODO: setUpPackageStorage should be in installPackage but we need to fix all tests first |
| setUpPackageStorage(applicationInfo); |
| packageInfo.applicationInfo = applicationInfo; |
| installPackage(packageInfo); |
| } |
| |
| /** This method is getting renamed to {link {@link #installPackage}. */ |
| @Deprecated |
| public void addPackage(PackageInfo packageInfo) { |
| installPackage(packageInfo); |
| } |
| |
| /** |
| * Testing API allowing to retrieve internal package representation. |
| * |
| * <p>This will allow to modify the package in a way visible to Robolectric, as this is |
| * Robolectric's internal full package representation. |
| * |
| * <p>Note that maybe a better way is to just modify the test manifest to make those modifications |
| * in a standard way. |
| * |
| * <p>Retrieving package info using {@link PackageManager#getPackageInfo} / {@link |
| * PackageManager#getApplicationInfo} will return defensive copies that will be stripped out of |
| * information according to provided flags. Don't use it to modify Robolectric state. |
| */ |
| public PackageInfo getInternalMutablePackageInfo(String packageName) { |
| return packageInfos.get(packageName); |
| } |
| |
| /** @deprecated Use {@link #getInternalMutablePackageInfo} instead. It has better name. */ |
| @Deprecated |
| public PackageInfo getPackageInfoForTesting(String packageName) { |
| return getInternalMutablePackageInfo(packageName); |
| } |
| |
| public void addPermissionInfo(PermissionInfo permissionInfo) { |
| extraPermissions.put(permissionInfo.name, permissionInfo); |
| } |
| |
| /** |
| * Adds {@code packageName} to the list of changed packages for the particular {@code |
| * sequenceNumber}. |
| * |
| * @param sequenceNumber has to be >= 0 |
| * @param packageName name of the package that was changed |
| */ |
| public void addChangedPackage(int sequenceNumber, String packageName) { |
| if (sequenceNumber < 0) { |
| return; |
| } |
| sequenceNumberChangedPackagesMap.put(sequenceNumber, packageName); |
| } |
| |
| /** |
| * Allows overriding or adding permission-group elements. These would be otherwise specified by |
| * either (the |
| * system)[https://developer.android.com/guide/topics/permissions/requesting.html#perm-groups] or |
| * by (the app |
| * itself)[https://developer.android.com/guide/topics/manifest/permission-group-element.html], as |
| * part of its manifest |
| * |
| * <p>{@link android.content.pm.PackageParser.PermissionGroup}s added through this method have |
| * precedence over those specified with the same name by one of the aforementioned methods. |
| * |
| * @see PackageManager#getAllPermissionGroups(int) |
| * @see PackageManager#getPermissionGroupInfo(String, int) |
| */ |
| public void addPermissionGroupInfo(PermissionGroupInfo permissionGroupInfo) { |
| extraPermissionGroups.put(permissionGroupInfo.name, permissionGroupInfo); |
| } |
| |
| public void removePackage(String packageName) { |
| packages.remove(packageName); |
| packageInfos.remove(packageName); |
| |
| packageSettings.remove(packageName); |
| } |
| |
| public void setSystemFeature(String name, boolean supported) { |
| systemFeatureList.put(name, supported); |
| } |
| |
| public void addDrawableResolution(String packageName, int resourceId, Drawable drawable) { |
| drawables.put(new Pair(packageName, resourceId), drawable); |
| } |
| |
| public void setNameForUid(int uid, String name) { |
| namesForUid.put(uid, name); |
| } |
| |
| public void setPackagesForCallingUid(String... packagesForCallingUid) { |
| packagesForUid.put(Binder.getCallingUid(), packagesForCallingUid); |
| for (String packageName : packagesForCallingUid) { |
| uidForPackage.put(packageName, Binder.getCallingUid()); |
| } |
| } |
| |
| public void setPackagesForUid(int uid, String... packagesForCallingUid) { |
| packagesForUid.put(uid, packagesForCallingUid); |
| for (String packageName : packagesForCallingUid) { |
| uidForPackage.put(packageName, uid); |
| } |
| } |
| |
| @Implementation |
| @Nullable |
| protected String[] getPackagesForUid(int uid) { |
| return packagesForUid.get(uid); |
| } |
| |
| public void setInstalledPackagesForUserId(int userId, List<String> packages) { |
| packagesForUserId.put(userId, packages); |
| for (String packageName : packages) { |
| addPackage(packageName); |
| } |
| } |
| |
| public void setPackageArchiveInfo(String archiveFilePath, PackageInfo packageInfo) { |
| packageArchiveInfo.put(archiveFilePath, packageInfo); |
| } |
| |
| public int getVerificationResult(int id) { |
| Integer result = verificationResults.get(id); |
| if (result == null) { |
| // 0 isn't a "valid" result, so we can check for the case when verification isn't |
| // called, if needed |
| return 0; |
| } |
| return result; |
| } |
| |
| public long getVerificationExtendedTimeout(int id) { |
| Long result = verificationTimeoutExtension.get(id); |
| if (result == null) { |
| return 0; |
| } |
| return result; |
| } |
| |
| public void setShouldShowRequestPermissionRationale(String permission, boolean show) { |
| permissionRationaleMap.put(permission, show); |
| } |
| |
| public void addSystemAvailableFeature(FeatureInfo featureInfo) { |
| systemAvailableFeatures.add(featureInfo); |
| } |
| |
| public void clearSystemAvailableFeatures() { |
| systemAvailableFeatures.clear(); |
| } |
| |
| /** Adds a value to be returned by {@link PackageManager#getSystemSharedLibraryNames()}. */ |
| public void addSystemSharedLibraryName(String name) { |
| systemSharedLibraryNames.add(name); |
| } |
| |
| /** Clears the values returned by {@link PackageManager#getSystemSharedLibraryNames()}. */ |
| public void clearSystemSharedLibraryNames() { |
| systemSharedLibraryNames.clear(); |
| } |
| |
| public void addCurrentToCannonicalName(String currentName, String canonicalName) { |
| currentToCanonicalNames.put(currentName, canonicalName); |
| } |
| |
| /** |
| * Sets if the {@link PackageManager} is allowed to request package installs through package |
| * installer. |
| */ |
| public void setCanRequestPackageInstalls(boolean canRequestPackageInstalls) { |
| ShadowPackageManager.canRequestPackageInstalls = canRequestPackageInstalls; |
| } |
| |
| @Implementation(minSdk = N) |
| protected List<ResolveInfo> queryBroadcastReceiversAsUser( |
| Intent intent, int flags, UserHandle userHandle) { |
| return null; |
| } |
| |
| @Implementation(minSdk = JELLY_BEAN_MR1) |
| protected List<ResolveInfo> queryBroadcastReceivers( |
| Intent intent, int flags, @UserIdInt int userId) { |
| return null; |
| } |
| |
| @Implementation |
| protected PackageInfo getPackageArchiveInfo(String archiveFilePath, int flags) { |
| List<PackageInfo> result = new ArrayList<>(); |
| for (PackageInfo packageInfo : packageInfos.values()) { |
| if (applicationEnabledSettingMap.get(packageInfo.packageName) |
| != COMPONENT_ENABLED_STATE_DISABLED |
| || (flags & MATCH_UNINSTALLED_PACKAGES) == MATCH_UNINSTALLED_PACKAGES) { |
| result.add(packageInfo); |
| } |
| } |
| |
| List<PackageInfo> packages = result; |
| for (PackageInfo aPackage : packages) { |
| ApplicationInfo appInfo = aPackage.applicationInfo; |
| if (appInfo != null && archiveFilePath.equals(appInfo.sourceDir)) { |
| return aPackage; |
| } |
| } |
| return null; |
| } |
| |
| @Implementation |
| protected void freeStorageAndNotify(long freeStorageSize, IPackageDataObserver observer) {} |
| |
| @Implementation |
| protected void freeStorage(long freeStorageSize, IntentSender pi) {} |
| |
| /** |
| * Runs the callbacks pending from calls to {@link PackageManager#deletePackage(String, |
| * IPackageDeleteObserver, int)} |
| */ |
| public void doPendingUninstallCallbacks() { |
| boolean hasDeletePackagesPermission = false; |
| String[] requestedPermissions = |
| packageInfos.get(RuntimeEnvironment.application.getPackageName()).requestedPermissions; |
| if (requestedPermissions != null) { |
| for (String permission : requestedPermissions) { |
| if (Manifest.permission.DELETE_PACKAGES.equals(permission)) { |
| hasDeletePackagesPermission = true; |
| break; |
| } |
| } |
| } |
| |
| for (String packageName : pendingDeleteCallbacks.keySet()) { |
| int resultCode = PackageManager.DELETE_FAILED_INTERNAL_ERROR; |
| |
| PackageInfo removed = packageInfos.get(packageName); |
| if (hasDeletePackagesPermission && removed != null) { |
| packageInfos.remove(packageName); |
| |
| packageSettings.remove(packageName); |
| |
| deletedPackages.add(packageName); |
| resultCode = PackageManager.DELETE_SUCCEEDED; |
| } |
| |
| try { |
| pendingDeleteCallbacks.get(packageName).packageDeleted(packageName, resultCode); |
| } catch (RemoteException e) { |
| throw new RuntimeException(e); |
| } |
| } |
| pendingDeleteCallbacks.clear(); |
| } |
| |
| /** |
| * Returns package names successfully deleted with {@link PackageManager#deletePackage(String, |
| * IPackageDeleteObserver, int)} Note that like real {@link PackageManager} the calling context |
| * must have {@link android.Manifest.permission#DELETE_PACKAGES} permission set. |
| */ |
| public Set<String> getDeletedPackages() { |
| return deletedPackages; |
| } |
| |
| protected List<ResolveInfo> queryOverriddenIntents(Intent intent, int flags) { |
| List<ResolveInfo> overrides = resolveInfoForIntent.get(intent); |
| if (overrides == null) { |
| return Collections.emptyList(); |
| } |
| List<ResolveInfo> result = new ArrayList<>(overrides.size()); |
| for (ResolveInfo resolveInfo : overrides) { |
| result.add(ShadowResolveInfo.newResolveInfo(resolveInfo)); |
| } |
| return result; |
| } |
| |
| /** |
| * Internal use only. |
| * |
| * @param appPackage |
| */ |
| public void addPackageInternal(Package appPackage) { |
| int flags = |
| GET_ACTIVITIES |
| | GET_RECEIVERS |
| | GET_SERVICES |
| | GET_PROVIDERS |
| | GET_INSTRUMENTATION |
| | GET_INTENT_FILTERS |
| | GET_SIGNATURES |
| | GET_RESOLVED_FILTER |
| | GET_META_DATA |
| | GET_GIDS |
| | MATCH_DISABLED_COMPONENTS |
| | GET_SHARED_LIBRARY_FILES |
| | GET_URI_PERMISSION_PATTERNS |
| | GET_PERMISSIONS |
| | MATCH_UNINSTALLED_PACKAGES |
| | GET_CONFIGURATIONS |
| | MATCH_DISABLED_UNTIL_USED_COMPONENTS |
| | MATCH_DIRECT_BOOT_UNAWARE |
| | MATCH_DIRECT_BOOT_AWARE; |
| |
| packages.put(appPackage.packageName, appPackage); |
| PackageInfo packageInfo; |
| if (RuntimeEnvironment.getApiLevel() >= M) { |
| packageInfo = |
| PackageParser.generatePackageInfo( |
| appPackage, |
| new int[] {0}, |
| flags, |
| 0, |
| 0, |
| new HashSet<String>(), |
| new PackageUserState()); |
| } else if (RuntimeEnvironment.getApiLevel() >= LOLLIPOP_MR1) { |
| packageInfo = |
| ReflectionHelpers.callStaticMethod( |
| PackageParser.class, |
| "generatePackageInfo", |
| ReflectionHelpers.ClassParameter.from(Package.class, appPackage), |
| ReflectionHelpers.ClassParameter.from(int[].class, new int[] {0}), |
| ReflectionHelpers.ClassParameter.from(int.class, flags), |
| ReflectionHelpers.ClassParameter.from(long.class, 0L), |
| ReflectionHelpers.ClassParameter.from(long.class, 0L), |
| ReflectionHelpers.ClassParameter.from(ArraySet.class, new ArraySet<>()), |
| ReflectionHelpers.ClassParameter.from( |
| PackageUserState.class, new PackageUserState())); |
| } else if (RuntimeEnvironment.getApiLevel() >= JELLY_BEAN_MR1) { |
| packageInfo = |
| ReflectionHelpers.callStaticMethod( |
| PackageParser.class, |
| "generatePackageInfo", |
| ReflectionHelpers.ClassParameter.from(Package.class, appPackage), |
| ReflectionHelpers.ClassParameter.from(int[].class, new int[] {0}), |
| ReflectionHelpers.ClassParameter.from(int.class, flags), |
| ReflectionHelpers.ClassParameter.from(long.class, 0L), |
| ReflectionHelpers.ClassParameter.from(long.class, 0L), |
| ReflectionHelpers.ClassParameter.from(HashSet.class, new HashSet<>()), |
| ReflectionHelpers.ClassParameter.from( |
| PackageUserState.class, new PackageUserState())); |
| } else { |
| packageInfo = |
| ReflectionHelpers.callStaticMethod( |
| PackageParser.class, |
| "generatePackageInfo", |
| ReflectionHelpers.ClassParameter.from(Package.class, appPackage), |
| ReflectionHelpers.ClassParameter.from(int[].class, new int[] {0}), |
| ReflectionHelpers.ClassParameter.from(int.class, flags), |
| ReflectionHelpers.ClassParameter.from(long.class, 0L), |
| ReflectionHelpers.ClassParameter.from(long.class, 0L), |
| ReflectionHelpers.ClassParameter.from(HashSet.class, new HashSet<>())); |
| } |
| |
| packageInfo.applicationInfo.uid = Process.myUid(); |
| packageInfo.applicationInfo.dataDir = |
| RuntimeEnvironment.getTempDirectory() |
| .createIfNotExists(packageInfo.packageName + "-dataDir") |
| .toString(); |
| installPackage(packageInfo); |
| } |
| |
| public static class IntentComparator implements Comparator<Intent> { |
| |
| @Override |
| public int compare(Intent i1, Intent i2) { |
| if (i1 == null && i2 == null) return 0; |
| if (i1 == null && i2 != null) return -1; |
| if (i1 != null && i2 == null) return 1; |
| if (i1.equals(i2)) return 0; |
| String action1 = i1.getAction(); |
| String action2 = i2.getAction(); |
| if (action1 == null && action2 != null) return -1; |
| if (action1 != null && action2 == null) return 1; |
| if (action1 != null && action2 != null) { |
| if (!action1.equals(action2)) { |
| return action1.compareTo(action2); |
| } |
| } |
| Uri data1 = i1.getData(); |
| Uri data2 = i2.getData(); |
| if (data1 == null && data2 != null) return -1; |
| if (data1 != null && data2 == null) return 1; |
| if (data1 != null && data2 != null) { |
| if (!data1.equals(data2)) { |
| return data1.compareTo(data2); |
| } |
| } |
| ComponentName component1 = i1.getComponent(); |
| ComponentName component2 = i2.getComponent(); |
| if (component1 == null && component2 != null) return -1; |
| if (component1 != null && component2 == null) return 1; |
| if (component1 != null && component2 != null) { |
| if (!component1.equals(component2)) { |
| return component1.compareTo(component2); |
| } |
| } |
| String package1 = i1.getPackage(); |
| String package2 = i2.getPackage(); |
| if (package1 == null && package2 != null) return -1; |
| if (package1 != null && package2 == null) return 1; |
| if (package1 != null && package2 != null) { |
| if (!package1.equals(package2)) { |
| return package1.compareTo(package2); |
| } |
| } |
| Set<String> categories1 = i1.getCategories(); |
| Set<String> categories2 = i2.getCategories(); |
| if (categories1 == null) return categories2 == null ? 0 : -1; |
| if (categories2 == null) return 1; |
| if (categories1.size() > categories2.size()) return 1; |
| if (categories1.size() < categories2.size()) return -1; |
| String[] array1 = categories1.toArray(new String[0]); |
| String[] array2 = categories2.toArray(new String[0]); |
| Arrays.sort(array1); |
| Arrays.sort(array2); |
| for (int i = 0; i < array1.length; ++i) { |
| int val = array1[i].compareTo(array2[i]); |
| if (val != 0) return val; |
| } |
| return 0; |
| } |
| } |
| |
| /** |
| * This class wraps {@link IntentFilter} so it has reasonable {@link #equals} and {@link |
| * #hashCode} methods. |
| */ |
| protected static class IntentFilterWrapper { |
| final IntentFilter filter; |
| private final HashSet<String> actions = new HashSet<>(); |
| private HashSet<String> categories = new HashSet<>(); |
| private HashSet<String> dataSchemes = new HashSet<>(); |
| private HashSet<String> dataSchemeSpecificParts = new HashSet<>(); |
| private HashSet<String> dataAuthorities = new HashSet<>(); |
| private HashSet<String> dataPaths = new HashSet<>(); |
| private HashSet<String> dataTypes = new HashSet<>(); |
| |
| public IntentFilterWrapper(IntentFilter filter) { |
| this.filter = filter; |
| if (filter == null) { |
| return; |
| } |
| for (int i = 0; i < filter.countActions(); i++) { |
| actions.add(filter.getAction(i)); |
| } |
| for (int i = 0; i < filter.countCategories(); i++) { |
| categories.add(filter.getCategory(i)); |
| } |
| for (int i = 0; i < filter.countDataAuthorities(); i++) { |
| AuthorityEntry dataAuthority = filter.getDataAuthority(i); |
| dataAuthorities.add(dataAuthority.getHost() + ":" + dataAuthority.getPort()); |
| } |
| for (int i = 0; i < filter.countDataPaths(); i++) { |
| PatternMatcher dataPath = filter.getDataPath(i); |
| dataPaths.add(dataPath.toString()); |
| } |
| for (int i = 0; i < filter.countDataSchemes(); i++) { |
| dataSchemes.add(filter.getDataScheme(i)); |
| } |
| if (VERSION.SDK_INT >= KITKAT) { |
| for (int i = 0; i < filter.countDataSchemeSpecificParts(); i++) { |
| dataSchemeSpecificParts.add(filter.getDataSchemeSpecificPart(i).toString()); |
| } |
| } |
| for (int i = 0; i < filter.countDataTypes(); i++) { |
| dataTypes.add(filter.getDataType(i)); |
| } |
| } |
| |
| @Override |
| public boolean equals(Object o) { |
| if (this == o) { |
| return true; |
| } |
| if (!(o instanceof IntentFilterWrapper)) { |
| return false; |
| } |
| IntentFilterWrapper that = (IntentFilterWrapper) o; |
| if (filter == null && that.filter == null) { |
| return true; |
| } |
| if (filter == null || that.filter == null) { |
| return false; |
| } |
| return filter.getPriority() == that.filter.getPriority() |
| && Objects.equals(actions, that.actions) |
| && Objects.equals(categories, that.categories) |
| && Objects.equals(dataSchemes, that.dataSchemes) |
| && Objects.equals(dataSchemeSpecificParts, that.dataSchemeSpecificParts) |
| && Objects.equals(dataAuthorities, that.dataAuthorities) |
| && Objects.equals(dataPaths, that.dataPaths) |
| && Objects.equals(dataTypes, that.dataTypes); |
| } |
| |
| @Override |
| public int hashCode() { |
| return Objects.hash( |
| filter == null ? null : filter.getPriority(), |
| actions, |
| categories, |
| dataSchemes, |
| dataSchemeSpecificParts, |
| dataAuthorities, |
| dataPaths, |
| dataTypes); |
| } |
| |
| public IntentFilter getFilter() { |
| return filter; |
| } |
| } |
| |
| /** Compares {@link ResolveInfo}, where better is bigger. */ |
| static class ResolveInfoComparator implements Comparator<ResolveInfo> { |
| |
| private final HashSet<ComponentName> preferredComponents; |
| |
| public ResolveInfoComparator(HashSet<ComponentName> preferredComponents) { |
| this.preferredComponents = preferredComponents; |
| } |
| |
| @Override |
| public int compare(ResolveInfo o1, ResolveInfo o2) { |
| if (o1 == null && o2 == null) { |
| return 0; |
| } |
| if (o1 == null) { |
| return -1; |
| } |
| if (o2 == null) { |
| return 1; |
| } |
| boolean o1isPreferred = isPreferred(o1); |
| boolean o2isPreferred = isPreferred(o2); |
| if (o1isPreferred != o2isPreferred) { |
| return Boolean.compare(o1isPreferred, o2isPreferred); |
| } |
| if (o1.preferredOrder != o2.preferredOrder) { |
| return Integer.compare(o1.preferredOrder, o2.preferredOrder); |
| } |
| if (o1.priority != o2.priority) { |
| return Integer.compare(o1.priority, o2.priority); |
| } |
| return 0; |
| } |
| |
| private boolean isPreferred(ResolveInfo resolveInfo) { |
| return resolveInfo.activityInfo != null |
| && resolveInfo.activityInfo.packageName != null |
| && resolveInfo.activityInfo.name != null |
| && preferredComponents.contains( |
| new ComponentName( |
| resolveInfo.activityInfo.packageName, resolveInfo.activityInfo.name)); |
| } |
| } |
| |
| protected static class ComponentState { |
| public int newState; |
| public int flags; |
| |
| public ComponentState(int newState, int flags) { |
| this.newState = newState; |
| this.flags = flags; |
| } |
| } |
| |
| /** |
| * Get list of intent filters defined for given activity. |
| * |
| * @param componentName Name of the activity whose intent filters are to be retrieved |
| * @return the activity's intent filters |
| */ |
| public List<IntentFilter> getIntentFiltersForActivity(ComponentName componentName) |
| throws NameNotFoundException { |
| return getIntentFiltersForComponent(getAppPackage(componentName).activities, componentName); |
| } |
| |
| /** |
| * Get list of intent filters defined for given service. |
| * |
| * @param componentName Name of the service whose intent filters are to be retrieved |
| * @return the service's intent filters |
| */ |
| public List<IntentFilter> getIntentFiltersForService(ComponentName componentName) |
| throws NameNotFoundException { |
| return getIntentFiltersForComponent(getAppPackage(componentName).services, componentName); |
| } |
| |
| /** |
| * Get list of intent filters defined for given receiver. |
| * |
| * @param componentName Name of the receiver whose intent filters are to be retrieved |
| * @return the receiver's intent filters |
| */ |
| public List<IntentFilter> getIntentFiltersForReceiver(ComponentName componentName) |
| throws NameNotFoundException { |
| return getIntentFiltersForComponent(getAppPackage(componentName).receivers, componentName); |
| } |
| |
| private static List<IntentFilter> getIntentFiltersForComponent( |
| List<? extends Component> components, ComponentName componentName) |
| throws NameNotFoundException { |
| for (Component component : components) { |
| if (component.getComponentName().equals(componentName)) { |
| return component.intents; |
| } |
| } |
| throw new NameNotFoundException("unknown component " + componentName); |
| } |
| |
| private static Package getAppPackage(ComponentName componentName) throws NameNotFoundException { |
| Package appPackage = packages.get(componentName.getPackageName()); |
| if (appPackage == null) { |
| throw new NameNotFoundException("unknown package " + componentName.getPackageName()); |
| } |
| return appPackage; |
| } |
| |
| /** |
| * Returns the current {@link PackageSetting} of {@code packageName}. |
| * |
| * <p>If {@code packageName} is not present in this {@link ShadowPackageManager}, this method will |
| * return null. |
| */ |
| public PackageSetting getPackageSetting(String packageName) { |
| PackageSetting setting = packageSettings.get(packageName); |
| return setting == null ? null : new PackageSetting(setting); |
| } |
| |
| @Resetter |
| public static void reset() { |
| permissionRationaleMap.clear(); |
| systemAvailableFeatures.clear(); |
| systemSharedLibraryNames.clear(); |
| packageInfos.clear(); |
| packages.clear(); |
| packageArchiveInfo.clear(); |
| packageStatsMap.clear(); |
| packageInstallerMap.clear(); |
| packagesForUid.clear(); |
| uidForPackage.clear(); |
| namesForUid.clear(); |
| verificationResults.clear(); |
| verificationTimeoutExtension.clear(); |
| currentToCanonicalNames.clear(); |
| componentList.clear(); |
| drawableList.clear(); |
| applicationIcons.clear(); |
| unbadgedApplicationIcons.clear(); |
| systemFeatureList.clear(); |
| preferredActivities.clear(); |
| drawables.clear(); |
| applicationEnabledSettingMap.clear(); |
| extraPermissions.clear(); |
| extraPermissionGroups.clear(); |
| resources.clear(); |
| resolveInfoForIntent.clear(); |
| deletedPackages.clear(); |
| pendingDeleteCallbacks.clear(); |
| hiddenPackages.clear(); |
| sequenceNumberChangedPackagesMap.clear(); |
| packagesForUserId.clear(); |
| |
| packageSettings.clear(); |
| } |
| } |
