content: /*
   * Copyright (C) 2015 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 android.content.pm;
  
  import android.annotation.IntDef;
  import android.annotation.NonNull;
  import android.annotation.Nullable;
  import android.annotation.UserIdInt;
  import android.content.ComponentName;
  import android.content.Intent;
  import android.content.IntentSender;
  import android.content.pm.PackageManager.ApplicationInfoFlags;
  import android.content.pm.PackageManager.ComponentInfoFlags;
  import android.content.pm.PackageManager.PackageInfoFlags;
  import android.content.pm.PackageManager.ResolveInfoFlags;
  import android.os.Bundle;
  import android.os.PersistableBundle;
  import android.util.ArraySet;
  import android.util.SparseArray;
  
  import com.android.internal.util.function.TriFunction;
  
  import java.io.IOException;
  import java.lang.annotation.Retention;
  import java.lang.annotation.RetentionPolicy;
  import java.util.List;
  import java.util.function.BiFunction;
  import java.util.function.Consumer;
  
  /**
   * Package manager local system service interface.
   *
   * @hide Only for use within the system server.
   */
  public abstract class PackageManagerInternal {
      public static final int PACKAGE_SYSTEM = 0;
      public static final int PACKAGE_SETUP_WIZARD = 1;
      public static final int PACKAGE_INSTALLER = 2;
      public static final int PACKAGE_VERIFIER = 3;
      public static final int PACKAGE_BROWSER = 4;
      public static final int PACKAGE_SYSTEM_TEXT_CLASSIFIER = 5;
      public static final int PACKAGE_PERMISSION_CONTROLLER = 6;
      public static final int PACKAGE_WELLBEING = 7;
      public static final int PACKAGE_DOCUMENTER = 8;
      public static final int PACKAGE_CONFIGURATOR = 9;
      public static final int PACKAGE_INCIDENT_REPORT_APPROVER = 10;
      public static final int PACKAGE_APP_PREDICTOR = 11;
      @IntDef(value = {
          PACKAGE_SYSTEM,
          PACKAGE_SETUP_WIZARD,
          PACKAGE_INSTALLER,
          PACKAGE_VERIFIER,
          PACKAGE_BROWSER,
          PACKAGE_SYSTEM_TEXT_CLASSIFIER,
          PACKAGE_PERMISSION_CONTROLLER,
          PACKAGE_WELLBEING,
          PACKAGE_DOCUMENTER,
          PACKAGE_CONFIGURATOR,
          PACKAGE_INCIDENT_REPORT_APPROVER,
          PACKAGE_APP_PREDICTOR,
      })
      @Retention(RetentionPolicy.SOURCE)
      public @interface KnownPackage {}
  
      /** Observer called whenever the list of packages changes */
      public interface PackageListObserver {
          /** A package was added to the system. */
          void onPackageAdded(@NonNull String packageName, int uid);
          /** A package was changed - either installed for a specific user or updated. */
          default void onPackageChanged(@NonNull String packageName, int uid) {}
          /** A package was removed from the system. */
          void onPackageRemoved(@NonNull String packageName, int uid);
      }
  
      /** Interface to override permission checks via composition */
      public interface CheckPermissionDelegate {
          /**
           * Allows overriding check permission behavior.
           *
           * @param permName The permission to check.
           * @param pkgName The package for which to check.
           * @param userId The user for which to check.
           * @param superImpl The super implementation.
           * @return The check permission result.
           */
          int checkPermission(String permName, String pkgName, int userId,
                  TriFunction<String, String, Integer, Integer> superImpl);
  
          /**
           * Allows overriding check UID permission behavior.
           *
           * @param permName The permission to check.
           * @param uid The UID for which to check.
           * @param superImpl The super implementation.
           * @return The check permission result.
           */
          int checkUidPermission(String permName, int uid,
                  BiFunction<String, Integer, Integer> superImpl);
      }
  
      /**
       * Provider for package names.
       */
      public interface PackagesProvider {
  
          /**
           * Gets the packages for a given user.
           * @param userId The user id.
           * @return The package names.
           */
          public String[] getPackages(int userId);
      }
  
      /**
       * Provider for package names.
       */
      public interface SyncAdapterPackagesProvider {
  
          /**
           * Gets the sync adapter packages for given authority and user.
           * @param authority The authority.
           * @param userId The user id.
           * @return The package names.
           */
          public String[] getPackages(String authority, int userId);
      }
  
      /**
       * Provider for default browser
       */
      public interface DefaultBrowserProvider {
  
          /**
           * Get the package name of the default browser.
           *
           * @param userId the user id
           *
           * @return the package name of the default browser, or {@code null} if none
           */
          @Nullable
          String getDefaultBrowser(@UserIdInt int userId);
  
          /**
           * Set the package name of the default browser.
           *
           * @param packageName package name of the default browser, or {@code null} to remove
           * @param userId the user id
           *
           * @return whether the default browser was successfully set.
           */
          boolean setDefaultBrowser(@Nullable String packageName, @UserIdInt int userId);
  
          /**
           * Set the package name of the default browser asynchronously.
           *
           * @param packageName package name of the default browser, or {@code null} to remove
           * @param userId the user id
           */
          void setDefaultBrowserAsync(@Nullable String packageName, @UserIdInt int userId);
      }
  
      /**
       * Provider for default dialer
       */
      public interface DefaultDialerProvider {
  
          /**
           * Get the package name of the default dialer.
           *
           * @param userId the user id
           *
           * @return the package name of the default dialer, or {@code null} if none
           */
          @Nullable
          String getDefaultDialer(@UserIdInt int userId);
      }
  
      /**
       * Provider for default home
       */
      public interface DefaultHomeProvider {
  
          /**
           * Get the package name of the default home.
           *
           * @param userId the user id
           *
           * @return the package name of the default home, or {@code null} if none
           */
          @Nullable
          String getDefaultHome(@UserIdInt int userId);
  
          /**
           * Set the package name of the default home.
           *
           * @param packageName package name of the default home, or {@code null} to remove
           * @param userId the user id
           * @param callback the callback made after the default home as been updated
           */
          void setDefaultHomeAsync(@Nullable String packageName, @UserIdInt int userId,
                  @NonNull Consumer<Boolean> callback);
      }
  
      /**
       * Sets the location provider packages provider.
       * @param provider The packages provider.
       */
      public abstract void setLocationPackagesProvider(PackagesProvider provider);
  
      /**
       * Set the location extra packages provider.
       * @param provider The packages provider.
       */
      public abstract  void setLocationExtraPackagesProvider(PackagesProvider provider);
  
      /**
       * Sets the voice interaction packages provider.
       * @param provider The packages provider.
       */
      public abstract void setVoiceInteractionPackagesProvider(PackagesProvider provider);
  
      /**
       * Sets the Use Open Wifi packages provider.
       * @param provider The packages provider.
       */
      public abstract void setUseOpenWifiAppPackagesProvider(PackagesProvider provider);
  
      /**
       * Sets the sync adapter packages provider.
       * @param provider The provider.
       */
      public abstract void setSyncAdapterPackagesprovider(SyncAdapterPackagesProvider provider);
  
      /**
       * Called when the package for the default SMS handler changed
       *
       * @param packageName the new sms package
       * @param userId user for which the change was made
       */
      public void onDefaultSmsAppChanged(String packageName, int userId) {}
  
      /**
       * Called when the package for the default sim call manager changed
       *
       * @param packageName the new sms package
       * @param userId user for which the change was made
       */
      public void onDefaultSimCallManagerAppChanged(String packageName, int userId) {}
  
      /**
       * Requests granting of the default permissions to the current default Use Open Wifi app.
       * @param packageName The default use open wifi package name.
       * @param userId The user for which to grant the permissions.
       */
      public abstract void grantDefaultPermissionsToDefaultUseOpenWifiApp(String packageName,
              int userId);
  
      /**
       * Sets a list of apps to keep in PM's internal data structures and as APKs even if no user has
       * currently installed it. The apps are not preloaded.
       * @param packageList List of package names to keep cached.
       */
      public abstract void setKeepUninstalledPackages(List<String> packageList);
  
      /**
       * Gets whether some of the permissions used by this package require a user
       * review before any of the app components can run.
       * @param packageName The package name for which to check.
       * @param userId The user under which to check.
       * @return True a permissions review is required.
       */
      public abstract boolean isPermissionsReviewRequired(String packageName, int userId);
  
      /**
       * Retrieve all of the information we know about a particular package/application.
       * @param filterCallingUid The results will be filtered in the context of this UID instead
       * of the calling UID.
       * @see PackageManager#getPackageInfo(String, int)
       */
      public abstract PackageInfo getPackageInfo(String packageName,
              @PackageInfoFlags int flags, int filterCallingUid, int userId);
  
      /**
       * Return a List of all application packages that are installed on the
       * device, for a specific user. If flag GET_UNINSTALLED_PACKAGES has been
       * set, a list of all applications including those deleted with
       * {@code DONT_DELETE_DATA} (partially installed apps with data directory)
       * will be returned.
       *
       * @param flags Additional option flags to modify the data returned.
       * @param userId The user for whom the installed applications are to be
       *            listed
       * @param callingUid The uid of the original caller app
       * @return A List of ApplicationInfo objects, one for each installed
       *         application. In the unlikely case there are no installed
       *         packages, an empty list is returned. If flag
       *         {@code MATCH_UNINSTALLED_PACKAGES} is set, the application
       *         information is retrieved from the list of uninstalled
       *         applications (which includes installed applications as well as
       *         applications with data directory i.e. applications which had been
       *         deleted with {@code DONT_DELETE_DATA} flag set).
       */
      public abstract List<ApplicationInfo> getInstalledApplications(
              @ApplicationInfoFlags int flags, @UserIdInt int userId, int callingUid);
  
      /**
       * Retrieve launcher extras for a suspended package provided to the system in
       * {@link PackageManager#setPackagesSuspended(String[], boolean, PersistableBundle,
       * PersistableBundle, String)}.
       *
       * @param packageName The package for which to return launcher extras.
       * @param userId The user for which to check.
       * @return The launcher extras.
       *
       * @see PackageManager#setPackagesSuspended(String[], boolean, PersistableBundle,
       * PersistableBundle, String)
       * @see PackageManager#isPackageSuspended()
       */
      public abstract Bundle getSuspendedPackageLauncherExtras(String packageName,
              int userId);
  
      /**
       * Internal api to query the suspended state of a package.
       * @param packageName The package to check.
       * @param userId The user id to check for.
       * @return {@code true} if the package is suspended, {@code false} otherwise.
       * @see PackageManager#isPackageSuspended(String)
       */
      public abstract boolean isPackageSuspended(String packageName, int userId);
  
      /**
       * Get the name of the package that suspended the given package. Packages can be suspended by
       * device administrators or apps holding {@link android.Manifest.permission#MANAGE_USERS} or
       * {@link android.Manifest.permission#SUSPEND_APPS}.
       *
       * @param suspendedPackage The package that has been suspended.
       * @param userId The user for which to check.
       * @return Name of the package that suspended the given package. Returns {@code null} if the
       * given package is not currently suspended and the platform package name - i.e.
       * {@code "android"} - if the package was suspended by a device admin.
       */
      public abstract String getSuspendingPackage(String suspendedPackage, int userId);
  
      /**
       * Get the information describing the dialog to be shown to the user when they try to launch a
       * suspended application.
       *
       * @param suspendedPackage The package that has been suspended.
       * @param userId The user for which to check.
       * @return A {@link SuspendDialogInfo} object describing the dialog to be shown.
       */
      @Nullable
      public abstract SuspendDialogInfo getSuspendedDialogInfo(String suspendedPackage, int userId);
  
      /**
       * Gets any distraction flags set via
       * {@link PackageManager#setDistractingPackageRestrictions(String[], int)}
       *
       * @param packageName
       * @param userId
       * @return A bitwise OR of any of the {@link PackageManager.DistractionRestriction}
       */
      public abstract @PackageManager.DistractionRestriction int getDistractingPackageRestrictions(
              String packageName, int userId);
  
      /**
       * Do a straight uid lookup for the given package/application in the given user.
       * @see PackageManager#getPackageUidAsUser(String, int, int)
       * @return The app's uid, or < 0 if the package was not found in that user
       */
      public abstract int getPackageUid(String packageName,
              @PackageInfoFlags int flags, int userId);
  
      /**
       * Retrieve all of the information we know about a particular package/application.
       * @param filterCallingUid The results will be filtered in the context of this UID instead
       * of the calling UID.
       * @see PackageManager#getApplicationInfo(String, int)
       */
      public abstract ApplicationInfo getApplicationInfo(String packageName,
              @ApplicationInfoFlags int flags, int filterCallingUid, int userId);
  
      /**
       * Retrieve all of the information we know about a particular activity class.
       * @param filterCallingUid The results will be filtered in the context of this UID instead
       * of the calling UID.
       * @see PackageManager#getActivityInfo(ComponentName, int)
       */
      public abstract ActivityInfo getActivityInfo(ComponentName component,
              @ComponentInfoFlags int flags, int filterCallingUid, int userId);
  
      /**
       * Retrieve all activities that can be performed for the given intent.
       * @param filterCallingUid The results will be filtered in the context of this UID instead
       * of the calling UID.
       * @see PackageManager#queryIntentActivities(Intent, int)
       */
      public abstract List<ResolveInfo> queryIntentActivities(Intent intent,
              @ResolveInfoFlags int flags, int filterCallingUid, int userId);
  
      /**
       * Retrieve all services that can be performed for the given intent.
       * @see PackageManager#queryIntentServices(Intent, int)
       */
      public abstract List<ResolveInfo> queryIntentServices(
              Intent intent, int flags, int callingUid, int userId);
  
      /**
       * Interface to {@link com.android.server.pm.PackageManagerService#getHomeActivitiesAsUser}.
       */
      public abstract ComponentName getHomeActivitiesAsUser(List<ResolveInfo> allHomeCandidates,
              int userId);
  
      /**
       * @return The default home activity component name.
       */
      public abstract ComponentName getDefaultHomeActivity(int userId);
  
      /**
       * Called by DeviceOwnerManagerService to set the package names of device owner and profile
       * owners.
       */
      public abstract void setDeviceAndProfileOwnerPackages(
              int deviceOwnerUserId, String deviceOwner, SparseArray<String> profileOwners);
  
      /**
       * Returns {@code true} if a given package can't be wiped. Otherwise, returns {@code false}.
       */
      public abstract boolean isPackageDataProtected(int userId, String packageName);
  
      /**
       * Returns {@code true} if a given package's state is protected, e.g. it cannot be force
       * stopped, suspended, disabled or hidden. Otherwise, returns {@code false}.
       */
      public abstract boolean isPackageStateProtected(String packageName, int userId);
  
      /**
       * Returns {@code true} if a given package is installed as ephemeral. Otherwise, returns
       * {@code false}.
       */
      public abstract boolean isPackageEphemeral(int userId, String packageName);
  
      /**
       * Gets whether the package was ever launched.
       * @param packageName The package name.
       * @param userId The user for which to check.
       * @return Whether was launched.
       * @throws IllegalArgumentException if the package is not found
       */
      public abstract boolean wasPackageEverLaunched(String packageName, int userId);
  
      /**
       * Grants a runtime permission
       * @param packageName The package name.
       * @param name The name of the permission.
       * @param userId The userId for which to grant the permission.
       * @param overridePolicy If true, grant this permission even if it is fixed by policy.
       */
      public abstract void grantRuntimePermission(String packageName, String name, int userId,
              boolean overridePolicy);
  
      /**
       * Revokes a runtime permission
       * @param packageName The package name.
       * @param name The name of the permission.
       * @param userId The userId for which to revoke the permission.
       * @param overridePolicy If true, revoke this permission even if it is fixed by policy.
       */
      public abstract void revokeRuntimePermission(String packageName, String name, int userId,
              boolean overridePolicy);
  
      /**
       * Retrieve the official name associated with a uid. This name is
       * guaranteed to never change, though it is possible for the underlying
       * uid to be changed. That is, if you are storing information about
       * uids in persistent storage, you should use the string returned
       * by this function instead of the raw uid.
       *
       * @param uid The uid for which you would like to retrieve a name.
       * @return Returns a unique name for the given uid, or null if the
       * uid is not currently assigned.
       */
      public abstract String getNameForUid(int uid);
  
      /**
       * Request to perform the second phase of ephemeral resolution.
       * @param responseObj The response of the first phase of ephemeral resolution
       * @param origIntent The original intent that triggered ephemeral resolution
       * @param resolvedType The resolved type of the intent
       * @param callingPackage The name of the package requesting the ephemeral application
       * @param verificationBundle Optional bundle to pass to the installer for additional
       * verification
       * @param userId The ID of the user that triggered ephemeral resolution
       */
      public abstract void requestInstantAppResolutionPhaseTwo(AuxiliaryResolveInfo responseObj,
              Intent origIntent, String resolvedType, String callingPackage,
              Bundle verificationBundle, int userId);
  
      /**
       * Grants access to the package metadata for an ephemeral application.
       * <p>
       * When an ephemeral application explicitly tries to interact with a full
       * install application [via an activity, service or provider that has been
       * exposed using the {@code visibleToInstantApp} attribute], the normal
       * application must be able to see metadata about the connecting ephemeral
       * app. If the ephemeral application uses an implicit intent [ie action VIEW,
       * category BROWSABLE], it remains hidden from the launched activity.
       * <p>
       * If the {@code sourceUid} is not for an ephemeral app or {@code targetUid}
       * is not for a fully installed app, this method will be a no-op.
       *
       * @param userId the user
       * @param intent the intent that triggered the grant
       * @param targetAppId The app ID of the fully installed application
       * @param ephemeralAppId The app ID of the ephemeral application
       */
      public abstract void grantEphemeralAccess(int userId, Intent intent,
              int targetAppId, int ephemeralAppId);
  
      public abstract boolean isInstantAppInstallerComponent(ComponentName component);
      /**
       * Prunes instant apps and state associated with uninstalled
       * instant apps according to the current platform policy.
       */
      public abstract void pruneInstantApps();
  
      /**
       * @return The SetupWizard package name.
       */
      public abstract String getSetupWizardPackageName();
  
      public interface ExternalSourcesPolicy {
  
          int USER_TRUSTED = 0;   // User has trusted the package to install apps
          int USER_BLOCKED = 1;   // User has blocked the package to install apps
          int USER_DEFAULT = 2;   // Default code to use when user response is unavailable
  
          /**
           * Checks the user preference for whether a package is trusted to request installs through
           * package installer
           *
           * @param packageName The package to check for
           * @param uid the uid in which the package is running
           * @return {@link #USER_TRUSTED} if the user has trusted the package, {@link #USER_BLOCKED}
           * if user has blocked requests from the package, {@link #USER_DEFAULT} if the user response
           * is not yet available
           */
          int getPackageTrustedToInstallApps(String packageName, int uid);
      }
  
      public abstract void setExternalSourcesPolicy(ExternalSourcesPolicy policy);
  
      /**
       * Return true if the given package is a persistent app process.
       */
      public abstract boolean isPackagePersistent(String packageName);
  
      /**
       * Returns whether or not the given package represents a legacy system application released
       * prior to runtime permissions.
       */
      public abstract boolean isLegacySystemApp(PackageParser.Package pkg);
  
      /**
       * Get all overlay packages for a user.
       * @param userId The user for which to get the overlays.
       * @return A list of overlay packages. An empty list is returned if the
       *         user has no installed overlay packages.
       */
      public abstract List<PackageInfo> getOverlayPackages(int userId);
  
      /**
       * Get the names of all target packages for a user.
       * @param userId The user for which to get the package names.
       * @return A list of target package names. This list includes the "android" package.
       */
      public abstract List<String> getTargetPackageNames(int userId);
  
      /**
       * Set which overlay to use for a package.
       * @param userId The user for which to update the overlays.
       * @param targetPackageName The package name of the package for which to update the overlays.
       * @param overlayPackageNames The complete list of overlay packages that should be enabled for
       *                            the target. Previously enabled overlays not specified in the list
       *                            will be disabled. Pass in null or an empty list to disable
       *                            all overlays. The order of the items is significant if several
       *                            overlays modify the same resource.
       * @return true if all packages names were known by the package manager, false otherwise
       */
      public abstract boolean setEnabledOverlayPackages(int userId, String targetPackageName,
              List<String> overlayPackageNames);
  
      /**
       * Resolves an activity intent, allowing instant apps to be resolved.
       */
      public abstract ResolveInfo resolveIntent(Intent intent, String resolvedType,
              int flags, int userId, boolean resolveForStart, int filterCallingUid);
  
      /**
      * Resolves a service intent, allowing instant apps to be resolved.
      */
      public abstract ResolveInfo resolveService(Intent intent, String resolvedType,
             int flags, int userId, int callingUid);
  
     /**
      * Resolves a content provider intent.
      */
      public abstract ProviderInfo resolveContentProvider(String name, int flags, int userId);
  
      /**
       * Track the creator of a new isolated uid.
       * @param isolatedUid The newly created isolated uid.
       * @param ownerUid The uid of the app that created the isolated process.
       */
      public abstract void addIsolatedUid(int isolatedUid, int ownerUid);
  
      /**
       * Track removal of an isolated uid.
       * @param isolatedUid isolated uid that is no longer being used.
       */
      public abstract void removeIsolatedUid(int isolatedUid);
  
      /**
       * Return the taget SDK version for the app with the given UID.
       */
      public abstract int getUidTargetSdkVersion(int uid);
  
      /**
       * Return the taget SDK version for the app with the given package name.
       */
      public abstract int getPackageTargetSdkVersion(String packageName);
  
      /** Whether the binder caller can access instant apps. */
      public abstract boolean canAccessInstantApps(int callingUid, int userId);
  
      /** Whether the binder caller can access the given component. */
      public abstract boolean canAccessComponent(int callingUid, ComponentName component, int userId);
  
      /**
       * Returns {@code true} if a given package has instant application meta-data.
       * Otherwise, returns {@code false}. Meta-data is state (eg. cookie, app icon, etc)
       * associated with an instant app. It may be kept after the instant app has been uninstalled.
       */
      public abstract boolean hasInstantApplicationMetadata(String packageName, int userId);
  
      /**
       * Updates a package last used time.
       */
      public abstract void notifyPackageUse(String packageName, int reason);
  
      /**
       * Returns a package object for the given package name.
       */
      public abstract @Nullable PackageParser.Package getPackage(@NonNull String packageName);
  
      /**
       * Returns a list without a change observer.
       *
       * @see #getPackageList(PackageListObserver)
       */
      public @NonNull PackageList getPackageList() {
          return getPackageList(null);
      }
  
      /**
       * Returns the list of packages installed at the time of the method call.
       * <p>The given observer is notified when the list of installed packages
       * changes [eg. a package was installed or uninstalled]. It will not be
       * notified if a package is updated.
       * <p>The package list will not be updated automatically as packages are
       * installed / uninstalled. Any changes must be handled within the observer.
       */
      public abstract @NonNull PackageList getPackageList(@Nullable PackageListObserver observer);
  
      /**
       * Removes the observer.
       * <p>Generally not needed. {@link #getPackageList(PackageListObserver)} will automatically
       * remove the observer.
       * <p>Does nothing if the observer isn't currently registered.
       * <p>Observers are notified asynchronously and it's possible for an observer to be
       * invoked after its been removed.
       */
      public abstract void removePackageListObserver(@NonNull PackageListObserver observer);
  
      /**
       * Returns a package object for the disabled system package name.
       */
      public abstract @Nullable PackageParser.Package getDisabledSystemPackage(
              @NonNull String packageName);
  
      /**
       * Returns the package name for the disabled system package.
       *
       * This is equivalent to
       * {@link #getDisabledSystemPackage(String)}.{@link PackageParser.Package#packageName}
       */
      public abstract @Nullable String getDisabledSystemPackageName(@NonNull String packageName);
  
      /**
       * Returns whether or not the component is the resolver activity.
       */
      public abstract boolean isResolveActivityComponent(@NonNull ComponentInfo component);
  
      /**
       * Returns the package name for a known package.
       */
      public abstract @Nullable String getKnownPackageName(
              @KnownPackage int knownPackage, int userId);
  
      /**
       * Returns whether the package is an instant app.
       */
      public abstract boolean isInstantApp(String packageName, int userId);
  
      /**
       * Returns whether the package is an instant app.
       */
      public abstract @Nullable String getInstantAppPackageName(int uid);
  
      /**
       * Returns whether or not access to the application should be filtered.
       * <p>
       * Access may be limited based upon whether the calling or target applications
       * are instant applications.
       *
       * @see #canAccessInstantApps
       */
      public abstract boolean filterAppAccess(
              @Nullable PackageParser.Package pkg, int callingUid, int userId);
  
      /*
       * NOTE: The following methods are temporary until permissions are extracted from
       * the package manager into a component specifically for handling permissions.
       */
      /** Returns the flags for the given permission. */
      public abstract @Nullable int getPermissionFlagsTEMP(@NonNull String permName,
              @NonNull String packageName, int userId);
      /** Updates the flags for the given permission. */
      public abstract void updatePermissionFlagsTEMP(@NonNull String permName,
              @NonNull String packageName, int flagMask, int flagValues, int userId);
  
      /** Returns whether the given package was signed by the platform */
      public abstract boolean isPlatformSigned(String pkg);
  
      /**
       * Returns true if it's still safe to restore data backed up from this app's version
       * that was signed with restoringFromSigHash.
       */
      public abstract boolean isDataRestoreSafe(@NonNull byte[] restoringFromSigHash,
              @NonNull String packageName);
  
      /**
       * Returns true if it's still safe to restore data backed up from this app's version
       * that was signed with restoringFromSig.
       */
      public abstract boolean isDataRestoreSafe(@NonNull Signature restoringFromSig,
              @NonNull String packageName);
  
      /**
       * Returns {@code true} if the the signing information for {@code clientUid} is sufficient
       * to gain access gated by {@code capability}.  This can happen if the two UIDs have the
       * same signing information, if the signing information {@code clientUid} indicates that
       * it has the signing certificate for {@code serverUid} in its signing history (if it was
       * previously signed by it), or if the signing certificate for {@code clientUid} is in the
       * signing history for {@code serverUid} and with the {@code capability} specified.
       */
      public abstract boolean hasSignatureCapability(int serverUid, int clientUid,
              @PackageParser.SigningDetails.CertCapabilities int capability);
  
      /**
       * Get the delegate to influence permission checking.
       *
       * @return The delegate instance or null to clear.
       */
      public abstract @Nullable CheckPermissionDelegate getCheckPermissionDelegate();
  
      /**
       * Set a delegate to influence permission checking.
       *
       * @param delegate A delegate instance or null to clear.
       */
      public abstract void setCheckPermissionDelegate(@Nullable CheckPermissionDelegate delegate);
  
      /**
       * Get appIds of all available apps which specified android:sharedUserId in the manifest.
       *
       * @return a SparseArray mapping from appId to it's sharedUserId.
       */
      public abstract SparseArray<String> getAppsWithSharedUserIds();
  
      /**
       * Get the value of attribute android:sharedUserId for the given packageName if specified,
       * otherwise {@code null}.
       */
      public abstract String getSharedUserIdForPackage(@NonNull String packageName);
  
      /**
       * Get all packages which specified the given sharedUserId as android:sharedUserId attribute
       * or an empty array if no package specified it.
       */
      public abstract String[] getPackagesForSharedUserId(@NonNull String sharedUserId, int userId);
  
      /**
       * Return if device is currently in a "core" boot environment, typically
       * used to support full-disk encryption. Only apps marked with
       * {@code coreApp} attribute are available.
       */
      public abstract boolean isOnlyCoreApps();
  
      /**
       * Make a best-effort attempt to provide the requested free disk space by
       * deleting cached files.
       *
       * @throws IOException if the request was unable to be fulfilled.
       */
      public abstract void freeStorage(String volumeUuid, long bytes, int storageFlags)
              throws IOException;
  
      /** Returns {@code true} if the specified component is enabled and matches the given flags. */
      public abstract boolean isEnabledAndMatches(@NonNull ComponentInfo info, int flags, int userId);
  
      /** Returns {@code true} if the given user requires extra badging for icons. */
      public abstract boolean userNeedsBadging(int userId);
  
      /**
       * Perform the given action for each package.
       * Note that packages lock will be held while performin the actions.
       *
       * @param actionLocked action to be performed
       */
      public abstract void forEachPackage(Consumer<PackageParser.Package> actionLocked);
  
      /**
       * Perform the given action for each installed package for a user.
       * Note that packages lock will be held while performin the actions.
       */
      public abstract void forEachInstalledPackage(
              @NonNull Consumer<PackageParser.Package> actionLocked, @UserIdInt int userId);
  
      /** Returns the list of enabled components */
      public abstract ArraySet<String> getEnabledComponents(String packageName, int userId);
  
      /** Returns the list of disabled components */
      public abstract ArraySet<String> getDisabledComponents(String packageName, int userId);
  
      /** Returns whether the given package is enabled for the given user */
      public abstract @PackageManager.EnabledState int getApplicationEnabledState(
              String packageName, int userId);
  
      /**
       * Extra field name for the token of a request to enable rollback for a
       * package.
       */
      public static final String EXTRA_ENABLE_ROLLBACK_TOKEN =
              "android.content.pm.extra.ENABLE_ROLLBACK_TOKEN";
  
      /**
       * Extra field name for the installFlags of a request to enable rollback
       * for a package.
       */
      public static final String EXTRA_ENABLE_ROLLBACK_INSTALL_FLAGS =
              "android.content.pm.extra.ENABLE_ROLLBACK_INSTALL_FLAGS";
  
      /**
       * Extra field name for the set of installed users for a given rollback package.
       */
      public static final String EXTRA_ENABLE_ROLLBACK_INSTALLED_USERS =
              "android.content.pm.extra.ENABLE_ROLLBACK_INSTALLED_USERS";
  
      /**
       * Extra field name for the user id an install is associated with when
       * enabling rollback.
       */
      public static final String EXTRA_ENABLE_ROLLBACK_USER =
              "android.content.pm.extra.ENABLE_ROLLBACK_USER";
  
      /**
       * Used as the {@code enableRollbackCode} argument for
       * {@link PackageManagerInternal#setEnableRollbackCode} to indicate that
       * enabling rollback succeeded.
       */
      public static final int ENABLE_ROLLBACK_SUCCEEDED = 1;
  
      /**
       * Used as the {@code enableRollbackCode} argument for
       * {@link PackageManagerInternal#setEnableRollbackCode} to indicate that
       * enabling rollback failed.
       */
      public static final int ENABLE_ROLLBACK_FAILED = -1;
  
      /**
       * Allows the rollback manager listening to the
       * {@link Intent#ACTION_PACKAGE_ENABLE_ROLLBACK enable rollback broadcast}
       * to respond to the package manager. The response must include the
       * {@code enableRollbackCode} which is one of
       * {@link PackageManager#ENABLE_ROLLBACK_SUCCEEDED} or
       * {@link PackageManager#ENABLE_ROLLBACK_FAILED}.
       *
       * @param token pending package identifier as passed via the
       *            {@link PackageManager#EXTRA_ENABLE_ROLLBACK_TOKEN} Intent extra.
       * @param enableRollbackCode the status code result of enabling rollback
       * @throws SecurityException if the caller does not have the
       *            PACKAGE_ROLLBACK_AGENT permission.
       */
      public abstract void setEnableRollbackCode(int token, int enableRollbackCode);
  
      /**
       * Ask the package manager to compile layouts in the given package.
       */
      public abstract boolean compileLayouts(String packageName);
  
      /*
       * Inform the package manager that the pending package install identified by
       * {@code token} can be completed.
       */
      public abstract void finishPackageInstall(int token, boolean didLaunch);
  
      /**
       * Remove the default browser stored in the legacy package settings.
       *
       * @param userId the user id
       *
       * @return the package name of the default browser, or {@code null} if none
       */
      @Nullable
      public abstract String removeLegacyDefaultBrowserPackageName(int userId);
  
      /**
       * Sets the default browser provider.
       *
       * @param provider the provider
       */
      public abstract void setDefaultBrowserProvider(@NonNull DefaultBrowserProvider provider);
  
      /**
       * Sets the default dialer provider.
       *
       * @param provider the provider
       */
      public abstract void setDefaultDialerProvider(@NonNull DefaultDialerProvider provider);
  
      /**
       * Sets the default home provider.
       *
       * @param provider the provider
       */
      public abstract void setDefaultHomeProvider(@NonNull DefaultHomeProvider provider);
  
      /**
       * Returns {@code true} if given {@code packageName} is an apex package.
       */
      public abstract boolean isApexPackage(String packageName);
  
      /**
       * Uninstalls given {@code packageName}.
       *
       * @param packageName apex package to uninstall.
       * @param versionCode version of a package to uninstall.
       * @param userId user to uninstall apex package for. Must be
       *               {@link android.os.UserHandle#USER_ALL}, otherwise failure will be reported.
       * @param intentSender a {@link IntentSender} to send result of an uninstall to.
       */
      public abstract void uninstallApex(String packageName, long versionCode, int userId,
              IntentSender intentSender);
  
      /**
       * Whether default permission grants have been performed for a user
       * since the device booted.
       *
       * @param userId The user id.
       * @return true if default permissions
       */
      public abstract boolean wereDefaultPermissionsGrantedSinceBoot(int userId);
  
      /**
       * Get fingerprint of build that updated the runtime permissions for a user.
       *
       * @param userId The user to update
       * @param fingerPrint The fingerprint to set
       */
      public abstract void setRuntimePermissionsFingerPrint(@NonNull String fingerPrint,
              @UserIdInt int userId);
  
      /**
       * Migrates legacy obb data to its new location.
       */
      public abstract void migrateLegacyObbData();
  
      /**
       * Ensures that we block deletion of unused packages on user removal. This is purely for the
       * purpose of ensuring that b/141413692 is not reproducible on Q.
       */
      public abstract void notifyingOnNextUserRemovalForTest();
  
      /**
       * Notifies PackageManager of the removal of a user. This is purely for the purpose of ensuring
       * that b/141413692 is not reproducible on Q.
       */
      public abstract void userRemovedForTest();
  }
  