1/*
2 * Copyright (C) 2015 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
17package android.content.pm;
18
19import android.content.ComponentName;
20import android.content.Intent;
21import android.content.pm.PackageManager.ApplicationInfoFlags;
22import android.content.pm.PackageManager.ComponentInfoFlags;
23import android.content.pm.PackageManager.PackageInfoFlags;
24import android.content.pm.PackageManager.ResolveInfoFlags;
25import android.os.Bundle;
26import android.util.SparseArray;
27
28import java.util.List;
29
30/**
31 * Package manager local system service interface.
32 *
33 * @hide Only for use within the system server.
34 */
35public abstract class PackageManagerInternal {
36
37    /**
38     * Provider for package names.
39     */
40    public interface PackagesProvider {
41
42        /**
43         * Gets the packages for a given user.
44         * @param userId The user id.
45         * @return The package names.
46         */
47        public String[] getPackages(int userId);
48    }
49
50    /**
51     * Provider for package names.
52     */
53    public interface SyncAdapterPackagesProvider {
54
55        /**
56         * Gets the sync adapter packages for given authority and user.
57         * @param authority The authority.
58         * @param userId The user id.
59         * @return The package names.
60         */
61        public String[] getPackages(String authority, int userId);
62    }
63
64    /**
65     * Sets the location provider packages provider.
66     * @param provider The packages provider.
67     */
68    public abstract void setLocationPackagesProvider(PackagesProvider provider);
69
70    /**
71     * Sets the voice interaction packages provider.
72     * @param provider The packages provider.
73     */
74    public abstract void setVoiceInteractionPackagesProvider(PackagesProvider provider);
75
76    /**
77     * Sets the SMS packages provider.
78     * @param provider The packages provider.
79     */
80    public abstract void setSmsAppPackagesProvider(PackagesProvider provider);
81
82    /**
83     * Sets the dialer packages provider.
84     * @param provider The packages provider.
85     */
86    public abstract void setDialerAppPackagesProvider(PackagesProvider provider);
87
88    /**
89     * Sets the sim call manager packages provider.
90     * @param provider The packages provider.
91     */
92    public abstract void setSimCallManagerPackagesProvider(PackagesProvider provider);
93
94    /**
95     * Sets the sync adapter packages provider.
96     * @param provider The provider.
97     */
98    public abstract void setSyncAdapterPackagesprovider(SyncAdapterPackagesProvider provider);
99
100    /**
101     * Requests granting of the default permissions to the current default SMS app.
102     * @param packageName The default SMS package name.
103     * @param userId The user for which to grant the permissions.
104     */
105    public abstract void grantDefaultPermissionsToDefaultSmsApp(String packageName, int userId);
106
107    /**
108     * Requests granting of the default permissions to the current default dialer app.
109     * @param packageName The default dialer package name.
110     * @param userId The user for which to grant the permissions.
111     */
112    public abstract void grantDefaultPermissionsToDefaultDialerApp(String packageName, int userId);
113
114    /**
115     * Requests granting of the default permissions to the current default sim call manager.
116     * @param packageName The default sim call manager package name.
117     * @param userId The user for which to grant the permissions.
118     */
119    public abstract void grantDefaultPermissionsToDefaultSimCallManager(String packageName,
120            int userId);
121
122    /**
123     * Sets a list of apps to keep in PM's internal data structures and as APKs even if no user has
124     * currently installed it. The apps are not preloaded.
125     * @param packageList List of package names to keep cached.
126     */
127    public abstract void setKeepUninstalledPackages(List<String> packageList);
128
129    /**
130     * Gets whether some of the permissions used by this package require a user
131     * review before any of the app components can run.
132     * @param packageName The package name for which to check.
133     * @param userId The user under which to check.
134     * @return True a permissions review is required.
135     */
136    public abstract boolean isPermissionsReviewRequired(String packageName, int userId);
137
138    /**
139     * Retrieve all of the information we know about a particular package/application.
140     * @param filterCallingUid The results will be filtered in the context of this UID instead
141     * of the calling UID.
142     * @see PackageManager#getPackageInfo(String, int)
143     */
144    public abstract PackageInfo getPackageInfo(String packageName,
145            @PackageInfoFlags int flags, int filterCallingUid, int userId);
146
147    /**
148     * Retrieve all of the information we know about a particular package/application.
149     * @param filterCallingUid The results will be filtered in the context of this UID instead
150     * of the calling UID.
151     * @see PackageManager#getApplicationInfo(String, int)
152     */
153    public abstract ApplicationInfo getApplicationInfo(String packageName,
154            @ApplicationInfoFlags int flags, int filterCallingUid, int userId);
155
156    /**
157     * Retrieve all of the information we know about a particular activity class.
158     * @param filterCallingUid The results will be filtered in the context of this UID instead
159     * of the calling UID.
160     * @see PackageManager#getActivityInfo(ComponentName, int)
161     */
162    public abstract ActivityInfo getActivityInfo(ComponentName component,
163            @ComponentInfoFlags int flags, int filterCallingUid, int userId);
164
165    /**
166     * Retrieve all activities that can be performed for the given intent.
167     * @param filterCallingUid The results will be filtered in the context of this UID instead
168     * of the calling UID.
169     * @see PackageManager#queryIntentActivities(Intent, int)
170     */
171    public abstract List<ResolveInfo> queryIntentActivities(Intent intent,
172            @ResolveInfoFlags int flags, int filterCallingUid, int userId);
173
174    /**
175     * Interface to {@link com.android.server.pm.PackageManagerService#getHomeActivitiesAsUser}.
176     */
177    public abstract ComponentName getHomeActivitiesAsUser(List<ResolveInfo> allHomeCandidates,
178            int userId);
179
180    /**
181     * Called by DeviceOwnerManagerService to set the package names of device owner and profile
182     * owners.
183     */
184    public abstract void setDeviceAndProfileOwnerPackages(
185            int deviceOwnerUserId, String deviceOwner, SparseArray<String> profileOwners);
186
187    /**
188     * Returns {@code true} if a given package can't be wiped. Otherwise, returns {@code false}.
189     */
190    public abstract boolean isPackageDataProtected(int userId, String packageName);
191
192    /**
193     * Returns {@code true} if a given package is installed as ephemeral. Otherwise, returns
194     * {@code false}.
195     */
196    public abstract boolean isPackageEphemeral(int userId, String packageName);
197
198    /**
199     * Gets whether the package was ever launched.
200     * @param packageName The package name.
201     * @param userId The user for which to check.
202     * @return Whether was launched.
203     * @throws IllegalArgumentException if the package is not found
204     */
205    public abstract boolean wasPackageEverLaunched(String packageName, int userId);
206
207    /**
208     * Grants a runtime permission
209     * @param packageName The package name.
210     * @param name The name of the permission.
211     * @param userId The userId for which to grant the permission.
212     * @param overridePolicy If true, grant this permission even if it is fixed by policy.
213     */
214    public abstract void grantRuntimePermission(String packageName, String name, int userId,
215            boolean overridePolicy);
216
217    /**
218     * Revokes a runtime permission
219     * @param packageName The package name.
220     * @param name The name of the permission.
221     * @param userId The userId for which to revoke the permission.
222     * @param overridePolicy If true, revoke this permission even if it is fixed by policy.
223     */
224    public abstract void revokeRuntimePermission(String packageName, String name, int userId,
225            boolean overridePolicy);
226
227    /**
228     * Retrieve the official name associated with a uid. This name is
229     * guaranteed to never change, though it is possible for the underlying
230     * uid to be changed. That is, if you are storing information about
231     * uids in persistent storage, you should use the string returned
232     * by this function instead of the raw uid.
233     *
234     * @param uid The uid for which you would like to retrieve a name.
235     * @return Returns a unique name for the given uid, or null if the
236     * uid is not currently assigned.
237     */
238    public abstract String getNameForUid(int uid);
239
240    /**
241     * Request to perform the second phase of ephemeral resolution.
242     * @param responseObj The response of the first phase of ephemeral resolution
243     * @param origIntent The original intent that triggered ephemeral resolution
244     * @param resolvedType The resolved type of the intent
245     * @param callingPackage The name of the package requesting the ephemeral application
246     * @param verificationBundle Optional bundle to pass to the installer for additional
247     * verification
248     * @param userId The ID of the user that triggered ephemeral resolution
249     */
250    public abstract void requestInstantAppResolutionPhaseTwo(AuxiliaryResolveInfo responseObj,
251            Intent origIntent, String resolvedType, String callingPackage,
252            Bundle verificationBundle, int userId);
253
254    /**
255     * Grants access to the package metadata for an ephemeral application.
256     * <p>
257     * When an ephemeral application explicitly tries to interact with a full
258     * install application [via an activity, service or provider that has been
259     * exposed using the {@code visibleToInstantApp} attribute], the normal
260     * application must be able to see metadata about the connecting ephemeral
261     * app. If the ephemeral application uses an implicit intent [ie action VIEW,
262     * category BROWSABLE], it remains hidden from the launched activity.
263     * <p>
264     * If the {@code sourceUid} is not for an ephemeral app or {@code targetUid}
265     * is not for a fully installed app, this method will be a no-op.
266     *
267     * @param userId the user
268     * @param intent the intent that triggered the grant
269     * @param targetAppId The app ID of the fully installed application
270     * @param ephemeralAppId The app ID of the ephemeral application
271     */
272    public abstract void grantEphemeralAccess(int userId, Intent intent,
273            int targetAppId, int ephemeralAppId);
274
275    public abstract boolean isInstantAppInstallerComponent(ComponentName component);
276    /**
277     * Prunes instant apps and state associated with uninstalled
278     * instant apps according to the current platform policy.
279     */
280    public abstract void pruneInstantApps();
281
282    /**
283     * @return The SetupWizard package name.
284     */
285    public abstract String getSetupWizardPackageName();
286
287    public interface ExternalSourcesPolicy {
288
289        int USER_TRUSTED = 0;   // User has trusted the package to install apps
290        int USER_BLOCKED = 1;   // User has blocked the package to install apps
291        int USER_DEFAULT = 2;   // Default code to use when user response is unavailable
292
293        /**
294         * Checks the user preference for whether a package is trusted to request installs through
295         * package installer
296         *
297         * @param packageName The package to check for
298         * @param uid the uid in which the package is running
299         * @return {@link USER_TRUSTED} if the user has trusted the package, {@link USER_BLOCKED}
300         * if user has blocked requests from the package, {@link USER_DEFAULT} if the user response
301         * is not yet available
302         */
303        int getPackageTrustedToInstallApps(String packageName, int uid);
304    }
305
306    public abstract void setExternalSourcesPolicy(ExternalSourcesPolicy policy);
307
308    /**
309     * Return true if the given package is a persistent app process.
310     */
311    public abstract boolean isPackagePersistent(String packageName);
312
313    /**
314     * Get all overlay packages for a user.
315     * @param userId The user for which to get the overlays.
316     * @return A list of overlay packages. An empty list is returned if the
317     *         user has no installed overlay packages.
318     */
319    public abstract List<PackageInfo> getOverlayPackages(int userId);
320
321    /**
322     * Get the names of all target packages for a user.
323     * @param userId The user for which to get the package names.
324     * @return A list of target package names. This list includes the "android" package.
325     */
326    public abstract List<String> getTargetPackageNames(int userId);
327
328    /**
329     * Set which overlay to use for a package.
330     * @param userId The user for which to update the overlays.
331     * @param targetPackageName The package name of the package for which to update the overlays.
332     * @param overlayPackageNames The complete list of overlay packages that should be enabled for
333     *                            the target. Previously enabled overlays not specified in the list
334     *                            will be disabled. Pass in null or an empty list to disable
335     *                            all overlays. The order of the items is significant if several
336     *                            overlays modify the same resource.
337     * @return true if all packages names were known by the package manager, false otherwise
338     */
339    public abstract boolean setEnabledOverlayPackages(int userId, String targetPackageName,
340            List<String> overlayPackageNames);
341
342    /**
343     * Resolves an activity intent, allowing instant apps to be resolved.
344     */
345    public abstract ResolveInfo resolveIntent(Intent intent, String resolvedType,
346            int flags, int userId);
347
348    /**
349    * Resolves a service intent, allowing instant apps to be resolved.
350    */
351   public abstract ResolveInfo resolveService(Intent intent, String resolvedType,
352           int flags, int userId, int callingUid);
353
354    /**
355     * Track the creator of a new isolated uid.
356     * @param isolatedUid The newly created isolated uid.
357     * @param ownerUid The uid of the app that created the isolated process.
358     */
359    public abstract void addIsolatedUid(int isolatedUid, int ownerUid);
360
361    /**
362     * Track removal of an isolated uid.
363     * @param isolatedUid isolated uid that is no longer being used.
364     */
365    public abstract void removeIsolatedUid(int isolatedUid);
366
367    /**
368     * Return the taget SDK version for the app with the given UID.
369     */
370    public abstract int getUidTargetSdkVersion(int uid);
371
372    /** Whether the binder caller can access instant apps. */
373    public abstract boolean canAccessInstantApps(int callingUid, int userId);
374
375    /**
376     * Returns {@code true} if a given package has instant application meta-data.
377     * Otherwise, returns {@code false}. Meta-data is state (eg. cookie, app icon, etc)
378     * associated with an instant app. It may be kept after the instant app has been uninstalled.
379     */
380    public abstract boolean hasInstantApplicationMetadata(String packageName, int userId);
381
382    /**
383     * Updates a package last used time.
384     */
385    public abstract void notifyPackageUse(String packageName, int reason);
386}
387