• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2006 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package android.content.pm;
18 
19 import android.annotation.SdkConstant;
20 import android.annotation.SdkConstant.SdkConstantType;
21 import android.content.ComponentName;
22 import android.content.Context;
23 import android.content.Intent;
24 import android.content.IntentFilter;
25 import android.content.IntentSender;
26 import android.content.res.Resources;
27 import android.content.res.XmlResourceParser;
28 import android.graphics.drawable.Drawable;
29 import android.net.Uri;
30 import android.os.Environment;
31 import android.util.AndroidException;
32 import android.util.DisplayMetrics;
33 
34 import java.io.File;
35 import java.util.List;
36 
37 /**
38  * Class for retrieving various kinds of information related to the application
39  * packages that are currently installed on the device.
40  *
41  * You can find this class through {@link Context#getPackageManager}.
42  */
43 public abstract class PackageManager {
44 
45     /**
46      * This exception is thrown when a given package, application, or component
47      * name can not be found.
48      */
49     public static class NameNotFoundException extends AndroidException {
NameNotFoundException()50         public NameNotFoundException() {
51         }
52 
NameNotFoundException(String name)53         public NameNotFoundException(String name) {
54             super(name);
55         }
56     }
57 
58     /**
59      * {@link PackageInfo} flag: return information about
60      * activities in the package in {@link PackageInfo#activities}.
61      */
62     public static final int GET_ACTIVITIES              = 0x00000001;
63 
64     /**
65      * {@link PackageInfo} flag: return information about
66      * intent receivers in the package in
67      * {@link PackageInfo#receivers}.
68      */
69     public static final int GET_RECEIVERS               = 0x00000002;
70 
71     /**
72      * {@link PackageInfo} flag: return information about
73      * services in the package in {@link PackageInfo#services}.
74      */
75     public static final int GET_SERVICES                = 0x00000004;
76 
77     /**
78      * {@link PackageInfo} flag: return information about
79      * content providers in the package in
80      * {@link PackageInfo#providers}.
81      */
82     public static final int GET_PROVIDERS               = 0x00000008;
83 
84     /**
85      * {@link PackageInfo} flag: return information about
86      * instrumentation in the package in
87      * {@link PackageInfo#instrumentation}.
88      */
89     public static final int GET_INSTRUMENTATION         = 0x00000010;
90 
91     /**
92      * {@link PackageInfo} flag: return information about the
93      * intent filters supported by the activity.
94      */
95     public static final int GET_INTENT_FILTERS          = 0x00000020;
96 
97     /**
98      * {@link PackageInfo} flag: return information about the
99      * signatures included in the package.
100      */
101     public static final int GET_SIGNATURES          = 0x00000040;
102 
103     /**
104      * {@link ResolveInfo} flag: return the IntentFilter that
105      * was matched for a particular ResolveInfo in
106      * {@link ResolveInfo#filter}.
107      */
108     public static final int GET_RESOLVED_FILTER         = 0x00000040;
109 
110     /**
111      * {@link ComponentInfo} flag: return the {@link ComponentInfo#metaData}
112      * data {@link android.os.Bundle}s that are associated with a component.
113      * This applies for any API returning a ComponentInfo subclass.
114      */
115     public static final int GET_META_DATA               = 0x00000080;
116 
117     /**
118      * {@link PackageInfo} flag: return the
119      * {@link PackageInfo#gids group ids} that are associated with an
120      * application.
121      * This applies for any API returning a PackageInfo class, either
122      * directly or nested inside of another.
123      */
124     public static final int GET_GIDS                    = 0x00000100;
125 
126     /**
127      * {@link PackageInfo} flag: include disabled components in the returned info.
128      */
129     public static final int GET_DISABLED_COMPONENTS     = 0x00000200;
130 
131     /**
132      * {@link ApplicationInfo} flag: return the
133      * {@link ApplicationInfo#sharedLibraryFiles paths to the shared libraries}
134      * that are associated with an application.
135      * This applies for any API returning an ApplicationInfo class, either
136      * directly or nested inside of another.
137      */
138     public static final int GET_SHARED_LIBRARY_FILES    = 0x00000400;
139 
140     /**
141      * {@link ProviderInfo} flag: return the
142      * {@link ProviderInfo#uriPermissionPatterns URI permission patterns}
143      * that are associated with a content provider.
144      * This applies for any API returning a ProviderInfo class, either
145      * directly or nested inside of another.
146      */
147     public static final int GET_URI_PERMISSION_PATTERNS  = 0x00000800;
148     /**
149      * {@link PackageInfo} flag: return information about
150      * permissions in the package in
151      * {@link PackageInfo#permissions}.
152      */
153     public static final int GET_PERMISSIONS               = 0x00001000;
154 
155     /**
156      * Flag parameter to retrieve some information about all applications (even
157      * uninstalled ones) which have data directories. This state could have
158      * resulted if applications have been deleted with flag
159      * {@code DONT_DELETE_DATA} with a possibility of being replaced or
160      * reinstalled in future.
161      * <p>
162      * Note: this flag may cause less information about currently installed
163      * applications to be returned.
164      */
165     public static final int GET_UNINSTALLED_PACKAGES = 0x00002000;
166 
167     /**
168      * {@link PackageInfo} flag: return information about
169      * hardware preferences in
170      * {@link PackageInfo#configPreferences PackageInfo.configPreferences} and
171      * requested features in {@link PackageInfo#reqFeatures
172      * PackageInfo.reqFeatures}.
173      */
174     public static final int GET_CONFIGURATIONS = 0x00004000;
175 
176     /**
177      * Resolution and querying flag: if set, only filters that support the
178      * {@link android.content.Intent#CATEGORY_DEFAULT} will be considered for
179      * matching.  This is a synonym for including the CATEGORY_DEFAULT in your
180      * supplied Intent.
181      */
182     public static final int MATCH_DEFAULT_ONLY   = 0x00010000;
183 
184     /**
185      * Permission check result: this is returned by {@link #checkPermission}
186      * if the permission has been granted to the given package.
187      */
188     public static final int PERMISSION_GRANTED = 0;
189 
190     /**
191      * Permission check result: this is returned by {@link #checkPermission}
192      * if the permission has not been granted to the given package.
193      */
194     public static final int PERMISSION_DENIED = -1;
195 
196     /**
197      * Signature check result: this is returned by {@link #checkSignatures}
198      * if all signatures on the two packages match.
199      */
200     public static final int SIGNATURE_MATCH = 0;
201 
202     /**
203      * Signature check result: this is returned by {@link #checkSignatures}
204      * if neither of the two packages is signed.
205      */
206     public static final int SIGNATURE_NEITHER_SIGNED = 1;
207 
208     /**
209      * Signature check result: this is returned by {@link #checkSignatures}
210      * if the first package is not signed but the second is.
211      */
212     public static final int SIGNATURE_FIRST_NOT_SIGNED = -1;
213 
214     /**
215      * Signature check result: this is returned by {@link #checkSignatures}
216      * if the second package is not signed but the first is.
217      */
218     public static final int SIGNATURE_SECOND_NOT_SIGNED = -2;
219 
220     /**
221      * Signature check result: this is returned by {@link #checkSignatures}
222      * if not all signatures on both packages match.
223      */
224     public static final int SIGNATURE_NO_MATCH = -3;
225 
226     /**
227      * Signature check result: this is returned by {@link #checkSignatures}
228      * if either of the packages are not valid.
229      */
230     public static final int SIGNATURE_UNKNOWN_PACKAGE = -4;
231 
232     /**
233      * Flag for {@link #setApplicationEnabledSetting(String, int, int)}
234      * and {@link #setComponentEnabledSetting(ComponentName, int, int)}: This
235      * component or application is in its default enabled state (as specified
236      * in its manifest).
237      */
238     public static final int COMPONENT_ENABLED_STATE_DEFAULT = 0;
239 
240     /**
241      * Flag for {@link #setApplicationEnabledSetting(String, int, int)}
242      * and {@link #setComponentEnabledSetting(ComponentName, int, int)}: This
243      * component or application has been explictily enabled, regardless of
244      * what it has specified in its manifest.
245      */
246     public static final int COMPONENT_ENABLED_STATE_ENABLED = 1;
247 
248     /**
249      * Flag for {@link #setApplicationEnabledSetting(String, int, int)}
250      * and {@link #setComponentEnabledSetting(ComponentName, int, int)}: This
251      * component or application has been explicitly disabled, regardless of
252      * what it has specified in its manifest.
253      */
254     public static final int COMPONENT_ENABLED_STATE_DISABLED = 2;
255 
256     /**
257      * Flag for {@link #setApplicationEnabledSetting(String, int, int)} only: The
258      * user has explicitly disabled the application, regardless of what it has
259      * specified in its manifest.  Because this is due to the user's request,
260      * they may re-enable it if desired through the appropriate system UI.  This
261      * option currently <strong>can not</strong> be used with
262      * {@link #setComponentEnabledSetting(ComponentName, int, int)}.
263      */
264     public static final int COMPONENT_ENABLED_STATE_DISABLED_USER = 3;
265 
266     /**
267      * Flag parameter for {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} to
268      * indicate that this package should be installed as forward locked, i.e. only the app itself
269      * should have access to its code and non-resource assets.
270      * @hide
271      */
272     public static final int INSTALL_FORWARD_LOCK = 0x00000001;
273 
274     /**
275      * Flag parameter for {@link #installPackage} to indicate that you want to replace an already
276      * installed package, if one exists.
277      * @hide
278      */
279     public static final int INSTALL_REPLACE_EXISTING = 0x00000002;
280 
281     /**
282      * Flag parameter for {@link #installPackage} to indicate that you want to
283      * allow test packages (those that have set android:testOnly in their
284      * manifest) to be installed.
285      * @hide
286      */
287     public static final int INSTALL_ALLOW_TEST = 0x00000004;
288 
289     /**
290      * Flag parameter for {@link #installPackage} to indicate that this
291      * package has to be installed on the sdcard.
292      * @hide
293      */
294     public static final int INSTALL_EXTERNAL = 0x00000008;
295 
296     /**
297      * Flag parameter for {@link #installPackage} to indicate that this package
298      * has to be installed on the sdcard.
299      * @hide
300      */
301     public static final int INSTALL_INTERNAL = 0x00000010;
302 
303     /**
304      * Flag parameter for {@link #installPackage} to indicate that this install
305      * was initiated via ADB.
306      *
307      * @hide
308      */
309     public static final int INSTALL_FROM_ADB = 0x00000020;
310 
311     /**
312      * Flag parameter for
313      * {@link #setComponentEnabledSetting(android.content.ComponentName, int, int)} to indicate
314      * that you don't want to kill the app containing the component.  Be careful when you set this
315      * since changing component states can make the containing application's behavior unpredictable.
316      */
317     public static final int DONT_KILL_APP = 0x00000001;
318 
319     /**
320      * Installation return code: this is passed to the {@link IPackageInstallObserver} by
321      * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} on success.
322      * @hide
323      */
324     public static final int INSTALL_SUCCEEDED = 1;
325 
326     /**
327      * Installation return code: this is passed to the {@link IPackageInstallObserver} by
328      * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if the package is
329      * already installed.
330      * @hide
331      */
332     public static final int INSTALL_FAILED_ALREADY_EXISTS = -1;
333 
334     /**
335      * Installation return code: this is passed to the {@link IPackageInstallObserver} by
336      * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if the package archive
337      * file is invalid.
338      * @hide
339      */
340     public static final int INSTALL_FAILED_INVALID_APK = -2;
341 
342     /**
343      * Installation return code: this is passed to the {@link IPackageInstallObserver} by
344      * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if the URI passed in
345      * is invalid.
346      * @hide
347      */
348     public static final int INSTALL_FAILED_INVALID_URI = -3;
349 
350     /**
351      * Installation return code: this is passed to the {@link IPackageInstallObserver} by
352      * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if the package manager
353      * service found that the device didn't have enough storage space to install the app.
354      * @hide
355      */
356     public static final int INSTALL_FAILED_INSUFFICIENT_STORAGE = -4;
357 
358     /**
359      * Installation return code: this is passed to the {@link IPackageInstallObserver} by
360      * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if a
361      * package is already installed with the same name.
362      * @hide
363      */
364     public static final int INSTALL_FAILED_DUPLICATE_PACKAGE = -5;
365 
366     /**
367      * Installation return code: this is passed to the {@link IPackageInstallObserver} by
368      * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if
369      * the requested shared user does not exist.
370      * @hide
371      */
372     public static final int INSTALL_FAILED_NO_SHARED_USER = -6;
373 
374     /**
375      * Installation return code: this is passed to the {@link IPackageInstallObserver} by
376      * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if
377      * a previously installed package of the same name has a different signature
378      * than the new package (and the old package's data was not removed).
379      * @hide
380      */
381     public static final int INSTALL_FAILED_UPDATE_INCOMPATIBLE = -7;
382 
383     /**
384      * Installation return code: this is passed to the {@link IPackageInstallObserver} by
385      * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if
386      * the new package is requested a shared user which is already installed on the
387      * device and does not have matching signature.
388      * @hide
389      */
390     public static final int INSTALL_FAILED_SHARED_USER_INCOMPATIBLE = -8;
391 
392     /**
393      * Installation return code: this is passed to the {@link IPackageInstallObserver} by
394      * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if
395      * the new package uses a shared library that is not available.
396      * @hide
397      */
398     public static final int INSTALL_FAILED_MISSING_SHARED_LIBRARY = -9;
399 
400     /**
401      * Installation return code: this is passed to the {@link IPackageInstallObserver} by
402      * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if
403      * the new package uses a shared library that is not available.
404      * @hide
405      */
406     public static final int INSTALL_FAILED_REPLACE_COULDNT_DELETE = -10;
407 
408     /**
409      * Installation return code: this is passed to the {@link IPackageInstallObserver} by
410      * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if
411      * the new package failed while optimizing and validating its dex files,
412      * either because there was not enough storage or the validation failed.
413      * @hide
414      */
415     public static final int INSTALL_FAILED_DEXOPT = -11;
416 
417     /**
418      * Installation return code: this is passed to the {@link IPackageInstallObserver} by
419      * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if
420      * the new package failed because the current SDK version is older than
421      * that required by the package.
422      * @hide
423      */
424     public static final int INSTALL_FAILED_OLDER_SDK = -12;
425 
426     /**
427      * Installation return code: this is passed to the {@link IPackageInstallObserver} by
428      * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if
429      * the new package failed because it contains a content provider with the
430      * same authority as a provider already installed in the system.
431      * @hide
432      */
433     public static final int INSTALL_FAILED_CONFLICTING_PROVIDER = -13;
434 
435     /**
436      * Installation return code: this is passed to the {@link IPackageInstallObserver} by
437      * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if
438      * the new package failed because the current SDK version is newer than
439      * that required by the package.
440      * @hide
441      */
442     public static final int INSTALL_FAILED_NEWER_SDK = -14;
443 
444     /**
445      * Installation return code: this is passed to the {@link IPackageInstallObserver} by
446      * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if
447      * the new package failed because it has specified that it is a test-only
448      * package and the caller has not supplied the {@link #INSTALL_ALLOW_TEST}
449      * flag.
450      * @hide
451      */
452     public static final int INSTALL_FAILED_TEST_ONLY = -15;
453 
454     /**
455      * Installation return code: this is passed to the {@link IPackageInstallObserver} by
456      * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if
457      * the package being installed contains native code, but none that is
458      * compatible with the the device's CPU_ABI.
459      * @hide
460      */
461     public static final int INSTALL_FAILED_CPU_ABI_INCOMPATIBLE = -16;
462 
463     /**
464      * Installation return code: this is passed to the {@link IPackageInstallObserver} by
465      * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if
466      * the new package uses a feature that is not available.
467      * @hide
468      */
469     public static final int INSTALL_FAILED_MISSING_FEATURE = -17;
470 
471     // ------ Errors related to sdcard
472     /**
473      * Installation return code: this is passed to the {@link IPackageInstallObserver} by
474      * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if
475      * a secure container mount point couldn't be accessed on external media.
476      * @hide
477      */
478     public static final int INSTALL_FAILED_CONTAINER_ERROR = -18;
479 
480     /**
481      * Installation return code: this is passed to the {@link IPackageInstallObserver} by
482      * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if
483      * the new package couldn't be installed in the specified install
484      * location.
485      * @hide
486      */
487     public static final int INSTALL_FAILED_INVALID_INSTALL_LOCATION = -19;
488 
489     /**
490      * Installation return code: this is passed to the {@link IPackageInstallObserver} by
491      * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if
492      * the new package couldn't be installed in the specified install
493      * location because the media is not available.
494      * @hide
495      */
496     public static final int INSTALL_FAILED_MEDIA_UNAVAILABLE = -20;
497 
498     /**
499      * Installation return code: this is passed to the {@link IPackageInstallObserver} by
500      * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if
501      * the new package couldn't be installed because the verification timed out.
502      * @hide
503      */
504     public static final int INSTALL_FAILED_VERIFICATION_TIMEOUT = -21;
505 
506     /**
507      * Installation return code: this is passed to the {@link IPackageInstallObserver} by
508      * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if
509      * the new package couldn't be installed because the verification did not succeed.
510      * @hide
511      */
512     public static final int INSTALL_FAILED_VERIFICATION_FAILURE = -22;
513 
514     /**
515      * Installation return code: this is passed to the {@link IPackageInstallObserver} by
516      * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if
517      * the package changed from what the calling program expected.
518      * @hide
519      */
520     public static final int INSTALL_FAILED_PACKAGE_CHANGED = -23;
521 
522     /**
523      * Installation return code: this is passed to the {@link IPackageInstallObserver} by
524      * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)} if
525      * the new package is assigned a different UID than it previously held.
526      * @hide
527      */
528     public static final int INSTALL_FAILED_UID_CHANGED = -24;
529 
530     /**
531      * Installation parse return code: this is passed to the {@link IPackageInstallObserver} by
532      * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)}
533      * if the parser was given a path that is not a file, or does not end with the expected
534      * '.apk' extension.
535      * @hide
536      */
537     public static final int INSTALL_PARSE_FAILED_NOT_APK = -100;
538 
539     /**
540      * Installation parse return code: this is passed to the {@link IPackageInstallObserver} by
541      * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)}
542      * if the parser was unable to retrieve the AndroidManifest.xml file.
543      * @hide
544      */
545     public static final int INSTALL_PARSE_FAILED_BAD_MANIFEST = -101;
546 
547     /**
548      * Installation parse return code: this is passed to the {@link IPackageInstallObserver} by
549      * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)}
550      * if the parser encountered an unexpected exception.
551      * @hide
552      */
553     public static final int INSTALL_PARSE_FAILED_UNEXPECTED_EXCEPTION = -102;
554 
555     /**
556      * Installation parse return code: this is passed to the {@link IPackageInstallObserver} by
557      * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)}
558      * if the parser did not find any certificates in the .apk.
559      * @hide
560      */
561     public static final int INSTALL_PARSE_FAILED_NO_CERTIFICATES = -103;
562 
563     /**
564      * Installation parse return code: this is passed to the {@link IPackageInstallObserver} by
565      * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)}
566      * if the parser found inconsistent certificates on the files in the .apk.
567      * @hide
568      */
569     public static final int INSTALL_PARSE_FAILED_INCONSISTENT_CERTIFICATES = -104;
570 
571     /**
572      * Installation parse return code: this is passed to the {@link IPackageInstallObserver} by
573      * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)}
574      * if the parser encountered a CertificateEncodingException in one of the
575      * files in the .apk.
576      * @hide
577      */
578     public static final int INSTALL_PARSE_FAILED_CERTIFICATE_ENCODING = -105;
579 
580     /**
581      * Installation parse return code: this is passed to the {@link IPackageInstallObserver} by
582      * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)}
583      * if the parser encountered a bad or missing package name in the manifest.
584      * @hide
585      */
586     public static final int INSTALL_PARSE_FAILED_BAD_PACKAGE_NAME = -106;
587 
588     /**
589      * Installation parse return code: this is passed to the {@link IPackageInstallObserver} by
590      * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)}
591      * if the parser encountered a bad shared user id name in the manifest.
592      * @hide
593      */
594     public static final int INSTALL_PARSE_FAILED_BAD_SHARED_USER_ID = -107;
595 
596     /**
597      * Installation parse return code: this is passed to the {@link IPackageInstallObserver} by
598      * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)}
599      * if the parser encountered some structural problem in the manifest.
600      * @hide
601      */
602     public static final int INSTALL_PARSE_FAILED_MANIFEST_MALFORMED = -108;
603 
604     /**
605      * Installation parse return code: this is passed to the {@link IPackageInstallObserver} by
606      * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)}
607      * if the parser did not find any actionable tags (instrumentation or application)
608      * in the manifest.
609      * @hide
610      */
611     public static final int INSTALL_PARSE_FAILED_MANIFEST_EMPTY = -109;
612 
613     /**
614      * Installation failed return code: this is passed to the {@link IPackageInstallObserver} by
615      * {@link #installPackage(android.net.Uri, IPackageInstallObserver, int)}
616      * if the system failed to install the package because of system issues.
617      * @hide
618      */
619     public static final int INSTALL_FAILED_INTERNAL_ERROR = -110;
620 
621     /**
622      * Flag parameter for {@link #deletePackage} to indicate that you don't want to delete the
623      * package's data directory.
624      *
625      * @hide
626      */
627     public static final int DONT_DELETE_DATA = 0x00000001;
628 
629     /**
630      * Return code for when package deletion succeeds. This is passed to the
631      * {@link IPackageDeleteObserver} by {@link #deletePackage()} if the system
632      * succeeded in deleting the package.
633      *
634      * @hide
635      */
636     public static final int DELETE_SUCCEEDED = 1;
637 
638     /**
639      * Deletion failed return code: this is passed to the
640      * {@link IPackageDeleteObserver} by {@link #deletePackage()} if the system
641      * failed to delete the package for an unspecified reason.
642      *
643      * @hide
644      */
645     public static final int DELETE_FAILED_INTERNAL_ERROR = -1;
646 
647     /**
648      * Deletion failed return code: this is passed to the
649      * {@link IPackageDeleteObserver} by {@link #deletePackage()} if the system
650      * failed to delete the package because it is the active DevicePolicy
651      * manager.
652      *
653      * @hide
654      */
655     public static final int DELETE_FAILED_DEVICE_POLICY_MANAGER = -2;
656 
657     /**
658      * Return code that is passed to the {@link IPackageMoveObserver} by
659      * {@link #movePackage(android.net.Uri, IPackageMoveObserver)} when the
660      * package has been successfully moved by the system.
661      *
662      * @hide
663      */
664     public static final int MOVE_SUCCEEDED = 1;
665     /**
666      * Error code that is passed to the {@link IPackageMoveObserver} by
667      * {@link #movePackage(android.net.Uri, IPackageMoveObserver)}
668      * when the package hasn't been successfully moved by the system
669      * because of insufficient memory on specified media.
670      * @hide
671      */
672     public static final int MOVE_FAILED_INSUFFICIENT_STORAGE = -1;
673 
674     /**
675      * Error code that is passed to the {@link IPackageMoveObserver} by
676      * {@link #movePackage(android.net.Uri, IPackageMoveObserver)}
677      * if the specified package doesn't exist.
678      * @hide
679      */
680     public static final int MOVE_FAILED_DOESNT_EXIST = -2;
681 
682     /**
683      * Error code that is passed to the {@link IPackageMoveObserver} by
684      * {@link #movePackage(android.net.Uri, IPackageMoveObserver)}
685      * if the specified package cannot be moved since its a system package.
686      * @hide
687      */
688     public static final int MOVE_FAILED_SYSTEM_PACKAGE = -3;
689 
690     /**
691      * Error code that is passed to the {@link IPackageMoveObserver} by
692      * {@link #movePackage(android.net.Uri, IPackageMoveObserver)}
693      * if the specified package cannot be moved since its forward locked.
694      * @hide
695      */
696     public static final int MOVE_FAILED_FORWARD_LOCKED = -4;
697 
698     /**
699      * Error code that is passed to the {@link IPackageMoveObserver} by
700      * {@link #movePackage(android.net.Uri, IPackageMoveObserver)}
701      * if the specified package cannot be moved to the specified location.
702      * @hide
703      */
704     public static final int MOVE_FAILED_INVALID_LOCATION = -5;
705 
706     /**
707      * Error code that is passed to the {@link IPackageMoveObserver} by
708      * {@link #movePackage(android.net.Uri, IPackageMoveObserver)}
709      * if the specified package cannot be moved to the specified location.
710      * @hide
711      */
712     public static final int MOVE_FAILED_INTERNAL_ERROR = -6;
713 
714     /**
715      * Error code that is passed to the {@link IPackageMoveObserver} by
716      * {@link #movePackage(android.net.Uri, IPackageMoveObserver)} if the
717      * specified package already has an operation pending in the
718      * {@link PackageHandler} queue.
719      *
720      * @hide
721      */
722     public static final int MOVE_FAILED_OPERATION_PENDING = -7;
723 
724     /**
725      * Flag parameter for {@link #movePackage} to indicate that
726      * the package should be moved to internal storage if its
727      * been installed on external media.
728      * @hide
729      */
730     public static final int MOVE_INTERNAL = 0x00000001;
731 
732     /**
733      * Flag parameter for {@link #movePackage} to indicate that
734      * the package should be moved to external media.
735      * @hide
736      */
737     public static final int MOVE_EXTERNAL_MEDIA = 0x00000002;
738 
739     /**
740      * Usable by the required verifier as the {@code verificationCode} argument
741      * for {@link PackageManager#verifyPendingInstall} to indicate that it will
742      * allow the installation to proceed without any of the optional verifiers
743      * needing to vote.
744      *
745      * @hide
746      */
747     public static final int VERIFICATION_ALLOW_WITHOUT_SUFFICIENT = 2;
748 
749     /**
750      * Used as the {@code verificationCode} argument for
751      * {@link PackageManager#verifyPendingInstall} to indicate that the calling
752      * package verifier allows the installation to proceed.
753      */
754     public static final int VERIFICATION_ALLOW = 1;
755 
756     /**
757      * Used as the {@code verificationCode} argument for
758      * {@link PackageManager#verifyPendingInstall} to indicate the calling
759      * package verifier does not vote to allow the installation to proceed.
760      */
761     public static final int VERIFICATION_REJECT = -1;
762 
763     /**
764      * Feature for {@link #getSystemAvailableFeatures} and {@link #hasSystemFeature}: The device's
765      * audio pipeline is low-latency, more suitable for audio applications sensitive to delays or
766      * lag in sound input or output.
767      */
768     @SdkConstant(SdkConstantType.FEATURE)
769     public static final String FEATURE_AUDIO_LOW_LATENCY = "android.hardware.audio.low_latency";
770 
771     /**
772      * Feature for {@link #getSystemAvailableFeatures} and
773      * {@link #hasSystemFeature}: The device is capable of communicating with
774      * other devices via Bluetooth.
775      */
776     @SdkConstant(SdkConstantType.FEATURE)
777     public static final String FEATURE_BLUETOOTH = "android.hardware.bluetooth";
778 
779     /**
780      * Feature for {@link #getSystemAvailableFeatures} and
781      * {@link #hasSystemFeature}: The device has a camera facing away
782      * from the screen.
783      */
784     @SdkConstant(SdkConstantType.FEATURE)
785     public static final String FEATURE_CAMERA = "android.hardware.camera";
786 
787     /**
788      * Feature for {@link #getSystemAvailableFeatures} and
789      * {@link #hasSystemFeature}: The device's camera supports auto-focus.
790      */
791     @SdkConstant(SdkConstantType.FEATURE)
792     public static final String FEATURE_CAMERA_AUTOFOCUS = "android.hardware.camera.autofocus";
793 
794     /**
795      * Feature for {@link #getSystemAvailableFeatures} and
796      * {@link #hasSystemFeature}: The device's camera supports flash.
797      */
798     @SdkConstant(SdkConstantType.FEATURE)
799     public static final String FEATURE_CAMERA_FLASH = "android.hardware.camera.flash";
800 
801     /**
802      * Feature for {@link #getSystemAvailableFeatures} and
803      * {@link #hasSystemFeature}: The device has a front facing camera.
804      */
805     @SdkConstant(SdkConstantType.FEATURE)
806     public static final String FEATURE_CAMERA_FRONT = "android.hardware.camera.front";
807 
808     /**
809      * Feature for {@link #getSystemAvailableFeatures} and
810      * {@link #hasSystemFeature}: The device supports one or more methods of
811      * reporting current location.
812      */
813     @SdkConstant(SdkConstantType.FEATURE)
814     public static final String FEATURE_LOCATION = "android.hardware.location";
815 
816     /**
817      * Feature for {@link #getSystemAvailableFeatures} and
818      * {@link #hasSystemFeature}: The device has a Global Positioning System
819      * receiver and can report precise location.
820      */
821     @SdkConstant(SdkConstantType.FEATURE)
822     public static final String FEATURE_LOCATION_GPS = "android.hardware.location.gps";
823 
824     /**
825      * Feature for {@link #getSystemAvailableFeatures} and
826      * {@link #hasSystemFeature}: The device can report location with coarse
827      * accuracy using a network-based geolocation system.
828      */
829     @SdkConstant(SdkConstantType.FEATURE)
830     public static final String FEATURE_LOCATION_NETWORK = "android.hardware.location.network";
831 
832     /**
833      * Feature for {@link #getSystemAvailableFeatures} and
834      * {@link #hasSystemFeature}: The device can record audio via a
835      * microphone.
836      */
837     @SdkConstant(SdkConstantType.FEATURE)
838     public static final String FEATURE_MICROPHONE = "android.hardware.microphone";
839 
840     /**
841      * Feature for {@link #getSystemAvailableFeatures} and
842      * {@link #hasSystemFeature}: The device can communicate using Near-Field
843      * Communications (NFC).
844      */
845     @SdkConstant(SdkConstantType.FEATURE)
846     public static final String FEATURE_NFC = "android.hardware.nfc";
847 
848     /**
849      * Feature for {@link #getSystemAvailableFeatures} and
850      * {@link #hasSystemFeature}: The device includes an accelerometer.
851      */
852     @SdkConstant(SdkConstantType.FEATURE)
853     public static final String FEATURE_SENSOR_ACCELEROMETER = "android.hardware.sensor.accelerometer";
854 
855     /**
856      * Feature for {@link #getSystemAvailableFeatures} and
857      * {@link #hasSystemFeature}: The device includes a barometer (air
858      * pressure sensor.)
859      */
860     @SdkConstant(SdkConstantType.FEATURE)
861     public static final String FEATURE_SENSOR_BAROMETER = "android.hardware.sensor.barometer";
862 
863     /**
864      * Feature for {@link #getSystemAvailableFeatures} and
865      * {@link #hasSystemFeature}: The device includes a magnetometer (compass).
866      */
867     @SdkConstant(SdkConstantType.FEATURE)
868     public static final String FEATURE_SENSOR_COMPASS = "android.hardware.sensor.compass";
869 
870     /**
871      * Feature for {@link #getSystemAvailableFeatures} and
872      * {@link #hasSystemFeature}: The device includes a gyroscope.
873      */
874     @SdkConstant(SdkConstantType.FEATURE)
875     public static final String FEATURE_SENSOR_GYROSCOPE = "android.hardware.sensor.gyroscope";
876 
877     /**
878      * Feature for {@link #getSystemAvailableFeatures} and
879      * {@link #hasSystemFeature}: The device includes a light sensor.
880      */
881     @SdkConstant(SdkConstantType.FEATURE)
882     public static final String FEATURE_SENSOR_LIGHT = "android.hardware.sensor.light";
883 
884     /**
885      * Feature for {@link #getSystemAvailableFeatures} and
886      * {@link #hasSystemFeature}: The device includes a proximity sensor.
887      */
888     @SdkConstant(SdkConstantType.FEATURE)
889     public static final String FEATURE_SENSOR_PROXIMITY = "android.hardware.sensor.proximity";
890 
891     /**
892      * Feature for {@link #getSystemAvailableFeatures} and
893      * {@link #hasSystemFeature}: The device has a telephony radio with data
894      * communication support.
895      */
896     @SdkConstant(SdkConstantType.FEATURE)
897     public static final String FEATURE_TELEPHONY = "android.hardware.telephony";
898 
899     /**
900      * Feature for {@link #getSystemAvailableFeatures} and
901      * {@link #hasSystemFeature}: The device has a CDMA telephony stack.
902      */
903     @SdkConstant(SdkConstantType.FEATURE)
904     public static final String FEATURE_TELEPHONY_CDMA = "android.hardware.telephony.cdma";
905 
906     /**
907      * Feature for {@link #getSystemAvailableFeatures} and
908      * {@link #hasSystemFeature}: The device has a GSM telephony stack.
909      */
910     @SdkConstant(SdkConstantType.FEATURE)
911     public static final String FEATURE_TELEPHONY_GSM = "android.hardware.telephony.gsm";
912 
913     /**
914      * Feature for {@link #getSystemAvailableFeatures} and
915      * {@link #hasSystemFeature}: The device supports connecting to USB devices
916      * as the USB host.
917      */
918     @SdkConstant(SdkConstantType.FEATURE)
919     public static final String FEATURE_USB_HOST = "android.hardware.usb.host";
920 
921     /**
922      * Feature for {@link #getSystemAvailableFeatures} and
923      * {@link #hasSystemFeature}: The device supports connecting to USB accessories.
924      */
925     @SdkConstant(SdkConstantType.FEATURE)
926     public static final String FEATURE_USB_ACCESSORY = "android.hardware.usb.accessory";
927 
928     /**
929      * Feature for {@link #getSystemAvailableFeatures} and
930      * {@link #hasSystemFeature}: The SIP API is enabled on the device.
931      */
932     @SdkConstant(SdkConstantType.FEATURE)
933     public static final String FEATURE_SIP = "android.software.sip";
934 
935     /**
936      * Feature for {@link #getSystemAvailableFeatures} and
937      * {@link #hasSystemFeature}: The device supports SIP-based VOIP.
938      */
939     @SdkConstant(SdkConstantType.FEATURE)
940     public static final String FEATURE_SIP_VOIP = "android.software.sip.voip";
941 
942     /**
943      * Feature for {@link #getSystemAvailableFeatures} and
944      * {@link #hasSystemFeature}: The device's display has a touch screen.
945      */
946     @SdkConstant(SdkConstantType.FEATURE)
947     public static final String FEATURE_TOUCHSCREEN = "android.hardware.touchscreen";
948 
949 
950     /**
951      * Feature for {@link #getSystemAvailableFeatures} and
952      * {@link #hasSystemFeature}: The device's touch screen supports
953      * multitouch sufficient for basic two-finger gesture detection.
954      */
955     @SdkConstant(SdkConstantType.FEATURE)
956     public static final String FEATURE_TOUCHSCREEN_MULTITOUCH = "android.hardware.touchscreen.multitouch";
957 
958     /**
959      * Feature for {@link #getSystemAvailableFeatures} and
960      * {@link #hasSystemFeature}: The device's touch screen is capable of
961      * tracking two or more fingers fully independently.
962      */
963     @SdkConstant(SdkConstantType.FEATURE)
964     public static final String FEATURE_TOUCHSCREEN_MULTITOUCH_DISTINCT = "android.hardware.touchscreen.multitouch.distinct";
965 
966     /**
967      * Feature for {@link #getSystemAvailableFeatures} and
968      * {@link #hasSystemFeature}: The device's touch screen is capable of
969      * tracking a full hand of fingers fully independently -- that is, 5 or
970      * more simultaneous independent pointers.
971      */
972     @SdkConstant(SdkConstantType.FEATURE)
973     public static final String FEATURE_TOUCHSCREEN_MULTITOUCH_JAZZHAND = "android.hardware.touchscreen.multitouch.jazzhand";
974 
975     /**
976      * Feature for {@link #getSystemAvailableFeatures} and
977      * {@link #hasSystemFeature}: The device does not have a touch screen, but
978      * does support touch emulation for basic events. For instance, the
979      * device might use a mouse or remote control to drive a cursor, and
980      * emulate basic touch pointer events like down, up, drag, etc. All
981      * devices that support android.hardware.touchscreen or a sub-feature are
982      * presumed to also support faketouch.
983      */
984     @SdkConstant(SdkConstantType.FEATURE)
985     public static final String FEATURE_FAKETOUCH = "android.hardware.faketouch";
986 
987     /**
988      * Feature for {@link #getSystemAvailableFeatures} and
989      * {@link #hasSystemFeature}: The device does not have a touch screen, but
990      * does support touch emulation for basic events that supports distinct
991      * tracking of two or more fingers.  This is an extension of
992      * {@link #FEATURE_FAKETOUCH} for input devices with this capability.  Note
993      * that unlike a distinct multitouch screen as defined by
994      * {@link #FEATURE_TOUCHSCREEN_MULTITOUCH_DISTINCT}, these kinds of input
995      * devices will not actually provide full two-finger gestures since the
996      * input is being transformed to cursor movement on the screen.  That is,
997      * single finger gestures will move a cursor; two-finger swipes will
998      * result in single-finger touch events; other two-finger gestures will
999      * result in the corresponding two-finger touch event.
1000      */
1001     @SdkConstant(SdkConstantType.FEATURE)
1002     public static final String FEATURE_FAKETOUCH_MULTITOUCH_DISTINCT = "android.hardware.faketouch.multitouch.distinct";
1003 
1004     /**
1005      * Feature for {@link #getSystemAvailableFeatures} and
1006      * {@link #hasSystemFeature}: The device does not have a touch screen, but
1007      * does support touch emulation for basic events that supports tracking
1008      * a hand of fingers (5 or more fingers) fully independently.
1009      * This is an extension of
1010      * {@link #FEATURE_FAKETOUCH} for input devices with this capability.  Note
1011      * that unlike a multitouch screen as defined by
1012      * {@link #FEATURE_TOUCHSCREEN_MULTITOUCH_JAZZHAND}, not all two finger
1013      * gestures can be detected due to the limitations described for
1014      * {@link #FEATURE_FAKETOUCH_MULTITOUCH_DISTINCT}.
1015      */
1016     @SdkConstant(SdkConstantType.FEATURE)
1017     public static final String FEATURE_FAKETOUCH_MULTITOUCH_JAZZHAND = "android.hardware.faketouch.multitouch.jazzhand";
1018 
1019     /**
1020      * Feature for {@link #getSystemAvailableFeatures} and
1021      * {@link #hasSystemFeature}: The device supports portrait orientation
1022      * screens.  For backwards compatibility, you can assume that if neither
1023      * this nor {@link #FEATURE_SCREEN_LANDSCAPE} is set then the device supports
1024      * both portrait and landscape.
1025      */
1026     @SdkConstant(SdkConstantType.FEATURE)
1027     public static final String FEATURE_SCREEN_PORTRAIT = "android.hardware.screen.portrait";
1028 
1029     /**
1030      * Feature for {@link #getSystemAvailableFeatures} and
1031      * {@link #hasSystemFeature}: The device supports landscape orientation
1032      * screens.  For backwards compatibility, you can assume that if neither
1033      * this nor {@link #FEATURE_SCREEN_PORTRAIT} is set then the device supports
1034      * both portrait and landscape.
1035      */
1036     @SdkConstant(SdkConstantType.FEATURE)
1037     public static final String FEATURE_SCREEN_LANDSCAPE = "android.hardware.screen.landscape";
1038 
1039     /**
1040      * Feature for {@link #getSystemAvailableFeatures} and
1041      * {@link #hasSystemFeature}: The device supports live wallpapers.
1042      */
1043     @SdkConstant(SdkConstantType.FEATURE)
1044     public static final String FEATURE_LIVE_WALLPAPER = "android.software.live_wallpaper";
1045 
1046     /**
1047      * Feature for {@link #getSystemAvailableFeatures} and
1048      * {@link #hasSystemFeature}: The device supports WiFi (802.11) networking.
1049      */
1050     @SdkConstant(SdkConstantType.FEATURE)
1051     public static final String FEATURE_WIFI = "android.hardware.wifi";
1052 
1053     /**
1054      * Feature for {@link #getSystemAvailableFeatures} and
1055      * {@link #hasSystemFeature}: The device supports Wi-Fi Direct networking.
1056      */
1057     @SdkConstant(SdkConstantType.FEATURE)
1058     public static final String FEATURE_WIFI_DIRECT = "android.hardware.wifi.direct";
1059 
1060     /**
1061      * Feature for {@link #getSystemAvailableFeatures} and
1062      * {@link #hasSystemFeature}: This is a device dedicated to showing UI
1063      * on a television.  Television here is defined to be a typical living
1064      * room television experience: displayed on a big screen, where the user
1065      * is sitting far away from it, and the dominant form of input will be
1066      * something like a DPAD, not through touch or mouse.
1067      */
1068     @SdkConstant(SdkConstantType.FEATURE)
1069     public static final String FEATURE_TELEVISION = "android.hardware.type.television";
1070 
1071     /**
1072      * Action to external storage service to clean out removed apps.
1073      * @hide
1074      */
1075     public static final String ACTION_CLEAN_EXTERNAL_STORAGE
1076             = "android.content.pm.CLEAN_EXTERNAL_STORAGE";
1077 
1078     /**
1079      * Extra field name for the URI to a verification file. Passed to a package
1080      * verifier.
1081      *
1082      * @hide
1083      */
1084     public static final String EXTRA_VERIFICATION_URI = "android.content.pm.extra.VERIFICATION_URI";
1085 
1086     /**
1087      * Extra field name for the ID of a package pending verification. Passed to
1088      * a package verifier and is used to call back to
1089      * {@link PackageManager#verifyPendingInstall(int, int)}
1090      */
1091     public static final String EXTRA_VERIFICATION_ID = "android.content.pm.extra.VERIFICATION_ID";
1092 
1093     /**
1094      * Extra field name for the package identifier which is trying to install
1095      * the package.
1096      *
1097      * @hide
1098      */
1099     public static final String EXTRA_VERIFICATION_INSTALLER_PACKAGE
1100             = "android.content.pm.extra.VERIFICATION_INSTALLER_PACKAGE";
1101 
1102     /**
1103      * Extra field name for the requested install flags for a package pending
1104      * verification. Passed to a package verifier.
1105      *
1106      * @hide
1107      */
1108     public static final String EXTRA_VERIFICATION_INSTALL_FLAGS
1109             = "android.content.pm.extra.VERIFICATION_INSTALL_FLAGS";
1110 
1111     /**
1112      * Retrieve overall information about an application package that is
1113      * installed on the system.
1114      * <p>
1115      * Throws {@link NameNotFoundException} if a package with the given name can
1116      * not be found on the system.
1117      *
1118      * @param packageName The full name (i.e. com.google.apps.contacts) of the
1119      *            desired package.
1120      * @param flags Additional option flags. Use any combination of
1121      *            {@link #GET_ACTIVITIES}, {@link #GET_GIDS},
1122      *            {@link #GET_CONFIGURATIONS}, {@link #GET_INSTRUMENTATION},
1123      *            {@link #GET_PERMISSIONS}, {@link #GET_PROVIDERS},
1124      *            {@link #GET_RECEIVERS}, {@link #GET_SERVICES},
1125      *            {@link #GET_SIGNATURES}, {@link #GET_UNINSTALLED_PACKAGES} to
1126      *            modify the data returned.
1127      * @return Returns a PackageInfo object containing information about the
1128      *         package. If flag GET_UNINSTALLED_PACKAGES is set and if the
1129      *         package is not found in the list of installed applications, the
1130      *         package information is retrieved from the list of uninstalled
1131      *         applications(which includes installed applications as well as
1132      *         applications with data directory ie applications which had been
1133      *         deleted with DONT_DELTE_DATA flag set).
1134      * @see #GET_ACTIVITIES
1135      * @see #GET_GIDS
1136      * @see #GET_CONFIGURATIONS
1137      * @see #GET_INSTRUMENTATION
1138      * @see #GET_PERMISSIONS
1139      * @see #GET_PROVIDERS
1140      * @see #GET_RECEIVERS
1141      * @see #GET_SERVICES
1142      * @see #GET_SIGNATURES
1143      * @see #GET_UNINSTALLED_PACKAGES
1144      */
getPackageInfo(String packageName, int flags)1145     public abstract PackageInfo getPackageInfo(String packageName, int flags)
1146             throws NameNotFoundException;
1147 
1148     /**
1149      * Map from the current package names in use on the device to whatever
1150      * the current canonical name of that package is.
1151      * @param names Array of current names to be mapped.
1152      * @return Returns an array of the same size as the original, containing
1153      * the canonical name for each package.
1154      */
currentToCanonicalPackageNames(String[] names)1155     public abstract String[] currentToCanonicalPackageNames(String[] names);
1156 
1157     /**
1158      * Map from a packages canonical name to the current name in use on the device.
1159      * @param names Array of new names to be mapped.
1160      * @return Returns an array of the same size as the original, containing
1161      * the current name for each package.
1162      */
canonicalToCurrentPackageNames(String[] names)1163     public abstract String[] canonicalToCurrentPackageNames(String[] names);
1164 
1165     /**
1166      * Return a "good" intent to launch a front-door activity in a package,
1167      * for use for example to implement an "open" button when browsing through
1168      * packages.  The current implementation will look first for a main
1169      * activity in the category {@link Intent#CATEGORY_INFO}, next for a
1170      * main activity in the category {@link Intent#CATEGORY_LAUNCHER}, or return
1171      * null if neither are found.
1172      *
1173      * <p>Throws {@link NameNotFoundException} if a package with the given
1174      * name can not be found on the system.
1175      *
1176      * @param packageName The name of the package to inspect.
1177      *
1178      * @return Returns either a fully-qualified Intent that can be used to
1179      * launch the main activity in the package, or null if the package does
1180      * not contain such an activity.
1181      */
getLaunchIntentForPackage(String packageName)1182     public abstract Intent getLaunchIntentForPackage(String packageName);
1183 
1184     /**
1185      * Return an array of all of the secondary group-ids that have been
1186      * assigned to a package.
1187      *
1188      * <p>Throws {@link NameNotFoundException} if a package with the given
1189      * name can not be found on the system.
1190      *
1191      * @param packageName The full name (i.e. com.google.apps.contacts) of the
1192      *                    desired package.
1193      *
1194      * @return Returns an int array of the assigned gids, or null if there
1195      * are none.
1196      */
getPackageGids(String packageName)1197     public abstract int[] getPackageGids(String packageName)
1198             throws NameNotFoundException;
1199 
1200     /**
1201      * Retrieve all of the information we know about a particular permission.
1202      *
1203      * <p>Throws {@link NameNotFoundException} if a permission with the given
1204      * name can not be found on the system.
1205      *
1206      * @param name The fully qualified name (i.e. com.google.permission.LOGIN)
1207      *             of the permission you are interested in.
1208      * @param flags Additional option flags.  Use {@link #GET_META_DATA} to
1209      * retrieve any meta-data associated with the permission.
1210      *
1211      * @return Returns a {@link PermissionInfo} containing information about the
1212      *         permission.
1213      */
getPermissionInfo(String name, int flags)1214     public abstract PermissionInfo getPermissionInfo(String name, int flags)
1215             throws NameNotFoundException;
1216 
1217     /**
1218      * Query for all of the permissions associated with a particular group.
1219      *
1220      * <p>Throws {@link NameNotFoundException} if the given group does not
1221      * exist.
1222      *
1223      * @param group The fully qualified name (i.e. com.google.permission.LOGIN)
1224      *             of the permission group you are interested in.  Use null to
1225      *             find all of the permissions not associated with a group.
1226      * @param flags Additional option flags.  Use {@link #GET_META_DATA} to
1227      * retrieve any meta-data associated with the permissions.
1228      *
1229      * @return Returns a list of {@link PermissionInfo} containing information
1230      * about all of the permissions in the given group.
1231      */
queryPermissionsByGroup(String group, int flags)1232     public abstract List<PermissionInfo> queryPermissionsByGroup(String group,
1233             int flags) throws NameNotFoundException;
1234 
1235     /**
1236      * Retrieve all of the information we know about a particular group of
1237      * permissions.
1238      *
1239      * <p>Throws {@link NameNotFoundException} if a permission group with the given
1240      * name can not be found on the system.
1241      *
1242      * @param name The fully qualified name (i.e. com.google.permission_group.APPS)
1243      *             of the permission you are interested in.
1244      * @param flags Additional option flags.  Use {@link #GET_META_DATA} to
1245      * retrieve any meta-data associated with the permission group.
1246      *
1247      * @return Returns a {@link PermissionGroupInfo} containing information
1248      * about the permission.
1249      */
getPermissionGroupInfo(String name, int flags)1250     public abstract PermissionGroupInfo getPermissionGroupInfo(String name,
1251             int flags) throws NameNotFoundException;
1252 
1253     /**
1254      * Retrieve all of the known permission groups in the system.
1255      *
1256      * @param flags Additional option flags.  Use {@link #GET_META_DATA} to
1257      * retrieve any meta-data associated with the permission group.
1258      *
1259      * @return Returns a list of {@link PermissionGroupInfo} containing
1260      * information about all of the known permission groups.
1261      */
getAllPermissionGroups(int flags)1262     public abstract List<PermissionGroupInfo> getAllPermissionGroups(int flags);
1263 
1264     /**
1265      * Retrieve all of the information we know about a particular
1266      * package/application.
1267      *
1268      * <p>Throws {@link NameNotFoundException} if an application with the given
1269      * package name can not be found on the system.
1270      *
1271      * @param packageName The full name (i.e. com.google.apps.contacts) of an
1272      *                    application.
1273      * @param flags Additional option flags. Use any combination of
1274      * {@link #GET_META_DATA}, {@link #GET_SHARED_LIBRARY_FILES},
1275      * {@link #GET_UNINSTALLED_PACKAGES} to modify the data returned.
1276      *
1277      * @return  {@link ApplicationInfo} Returns ApplicationInfo object containing
1278      *         information about the package.
1279      *         If flag GET_UNINSTALLED_PACKAGES is set and  if the package is not
1280      *         found in the list of installed applications,
1281      *         the application information is retrieved from the
1282      *         list of uninstalled applications(which includes
1283      *         installed applications as well as applications
1284      *         with data directory ie applications which had been
1285      *         deleted with DONT_DELTE_DATA flag set).
1286      *
1287      * @see #GET_META_DATA
1288      * @see #GET_SHARED_LIBRARY_FILES
1289      * @see #GET_UNINSTALLED_PACKAGES
1290      */
getApplicationInfo(String packageName, int flags)1291     public abstract ApplicationInfo getApplicationInfo(String packageName,
1292             int flags) throws NameNotFoundException;
1293 
1294     /**
1295      * Retrieve all of the information we know about a particular activity
1296      * class.
1297      *
1298      * <p>Throws {@link NameNotFoundException} if an activity with the given
1299      * class name can not be found on the system.
1300      *
1301      * @param component The full component name (i.e.
1302      * com.google.apps.contacts/com.google.apps.contacts.ContactsList) of an Activity
1303      * class.
1304      * @param flags Additional option flags. Use any combination of
1305      * {@link #GET_META_DATA}, {@link #GET_SHARED_LIBRARY_FILES},
1306      * to modify the data (in ApplicationInfo) returned.
1307      *
1308      * @return {@link ActivityInfo} containing information about the activity.
1309      *
1310      * @see #GET_INTENT_FILTERS
1311      * @see #GET_META_DATA
1312      * @see #GET_SHARED_LIBRARY_FILES
1313      */
getActivityInfo(ComponentName component, int flags)1314     public abstract ActivityInfo getActivityInfo(ComponentName component,
1315             int flags) throws NameNotFoundException;
1316 
1317     /**
1318      * Retrieve all of the information we know about a particular receiver
1319      * class.
1320      *
1321      * <p>Throws {@link NameNotFoundException} if a receiver with the given
1322      * class name can not be found on the system.
1323      *
1324      * @param component The full component name (i.e.
1325      * com.google.apps.calendar/com.google.apps.calendar.CalendarAlarm) of a Receiver
1326      * class.
1327      * @param flags Additional option flags.  Use any combination of
1328      * {@link #GET_META_DATA}, {@link #GET_SHARED_LIBRARY_FILES},
1329      * to modify the data returned.
1330      *
1331      * @return {@link ActivityInfo} containing information about the receiver.
1332      *
1333      * @see #GET_INTENT_FILTERS
1334      * @see #GET_META_DATA
1335      * @see #GET_SHARED_LIBRARY_FILES
1336      */
getReceiverInfo(ComponentName component, int flags)1337     public abstract ActivityInfo getReceiverInfo(ComponentName component,
1338             int flags) throws NameNotFoundException;
1339 
1340     /**
1341      * Retrieve all of the information we know about a particular service
1342      * class.
1343      *
1344      * <p>Throws {@link NameNotFoundException} if a service with the given
1345      * class name can not be found on the system.
1346      *
1347      * @param component The full component name (i.e.
1348      * com.google.apps.media/com.google.apps.media.BackgroundPlayback) of a Service
1349      * class.
1350      * @param flags Additional option flags.  Use any combination of
1351      * {@link #GET_META_DATA}, {@link #GET_SHARED_LIBRARY_FILES},
1352      * to modify the data returned.
1353      *
1354      * @return ServiceInfo containing information about the service.
1355      *
1356      * @see #GET_META_DATA
1357      * @see #GET_SHARED_LIBRARY_FILES
1358      */
getServiceInfo(ComponentName component, int flags)1359     public abstract ServiceInfo getServiceInfo(ComponentName component,
1360             int flags) throws NameNotFoundException;
1361 
1362     /**
1363      * Retrieve all of the information we know about a particular content
1364      * provider class.
1365      *
1366      * <p>Throws {@link NameNotFoundException} if a provider with the given
1367      * class name can not be found on the system.
1368      *
1369      * @param component The full component name (i.e.
1370      * com.google.providers.media/com.google.providers.media.MediaProvider) of a
1371      * ContentProvider class.
1372      * @param flags Additional option flags.  Use any combination of
1373      * {@link #GET_META_DATA}, {@link #GET_SHARED_LIBRARY_FILES},
1374      * to modify the data returned.
1375      *
1376      * @return ProviderInfo containing information about the service.
1377      *
1378      * @see #GET_META_DATA
1379      * @see #GET_SHARED_LIBRARY_FILES
1380      */
getProviderInfo(ComponentName component, int flags)1381     public abstract ProviderInfo getProviderInfo(ComponentName component,
1382             int flags) throws NameNotFoundException;
1383 
1384     /**
1385      * Return a List of all packages that are installed
1386      * on the device.
1387      *
1388      * @param flags Additional option flags. Use any combination of
1389      * {@link #GET_ACTIVITIES},
1390      * {@link #GET_GIDS},
1391      * {@link #GET_CONFIGURATIONS},
1392      * {@link #GET_INSTRUMENTATION},
1393      * {@link #GET_PERMISSIONS},
1394      * {@link #GET_PROVIDERS},
1395      * {@link #GET_RECEIVERS},
1396      * {@link #GET_SERVICES},
1397      * {@link #GET_SIGNATURES},
1398      * {@link #GET_UNINSTALLED_PACKAGES} to modify the data returned.
1399      *
1400      * @return A List of PackageInfo objects, one for each package that is
1401      *         installed on the device.  In the unlikely case of there being no
1402      *         installed packages, an empty list is returned.
1403      *         If flag GET_UNINSTALLED_PACKAGES is set, a list of all
1404      *         applications including those deleted with DONT_DELETE_DATA
1405      *         (partially installed apps with data directory) will be returned.
1406      *
1407      * @see #GET_ACTIVITIES
1408      * @see #GET_GIDS
1409      * @see #GET_CONFIGURATIONS
1410      * @see #GET_INSTRUMENTATION
1411      * @see #GET_PERMISSIONS
1412      * @see #GET_PROVIDERS
1413      * @see #GET_RECEIVERS
1414      * @see #GET_SERVICES
1415      * @see #GET_SIGNATURES
1416      * @see #GET_UNINSTALLED_PACKAGES
1417      *
1418      */
getInstalledPackages(int flags)1419     public abstract List<PackageInfo> getInstalledPackages(int flags);
1420 
1421     /**
1422      * Check whether a particular package has been granted a particular
1423      * permission.
1424      *
1425      * @param permName The name of the permission you are checking for,
1426      * @param pkgName The name of the package you are checking against.
1427      *
1428      * @return If the package has the permission, PERMISSION_GRANTED is
1429      * returned.  If it does not have the permission, PERMISSION_DENIED
1430      * is returned.
1431      *
1432      * @see #PERMISSION_GRANTED
1433      * @see #PERMISSION_DENIED
1434      */
checkPermission(String permName, String pkgName)1435     public abstract int checkPermission(String permName, String pkgName);
1436 
1437     /**
1438      * Add a new dynamic permission to the system.  For this to work, your
1439      * package must have defined a permission tree through the
1440      * {@link android.R.styleable#AndroidManifestPermissionTree
1441      * &lt;permission-tree&gt;} tag in its manifest.  A package can only add
1442      * permissions to trees that were defined by either its own package or
1443      * another with the same user id; a permission is in a tree if it
1444      * matches the name of the permission tree + ".": for example,
1445      * "com.foo.bar" is a member of the permission tree "com.foo".
1446      *
1447      * <p>It is good to make your permission tree name descriptive, because you
1448      * are taking possession of that entire set of permission names.  Thus, it
1449      * must be under a domain you control, with a suffix that will not match
1450      * any normal permissions that may be declared in any applications that
1451      * are part of that domain.
1452      *
1453      * <p>New permissions must be added before
1454      * any .apks are installed that use those permissions.  Permissions you
1455      * add through this method are remembered across reboots of the device.
1456      * If the given permission already exists, the info you supply here
1457      * will be used to update it.
1458      *
1459      * @param info Description of the permission to be added.
1460      *
1461      * @return Returns true if a new permission was created, false if an
1462      * existing one was updated.
1463      *
1464      * @throws SecurityException if you are not allowed to add the
1465      * given permission name.
1466      *
1467      * @see #removePermission(String)
1468      */
addPermission(PermissionInfo info)1469     public abstract boolean addPermission(PermissionInfo info);
1470 
1471     /**
1472      * Like {@link #addPermission(PermissionInfo)} but asynchronously
1473      * persists the package manager state after returning from the call,
1474      * allowing it to return quicker and batch a series of adds at the
1475      * expense of no guarantee the added permission will be retained if
1476      * the device is rebooted before it is written.
1477      */
addPermissionAsync(PermissionInfo info)1478     public abstract boolean addPermissionAsync(PermissionInfo info);
1479 
1480     /**
1481      * Removes a permission that was previously added with
1482      * {@link #addPermission(PermissionInfo)}.  The same ownership rules apply
1483      * -- you are only allowed to remove permissions that you are allowed
1484      * to add.
1485      *
1486      * @param name The name of the permission to remove.
1487      *
1488      * @throws SecurityException if you are not allowed to remove the
1489      * given permission name.
1490      *
1491      * @see #addPermission(PermissionInfo)
1492      */
removePermission(String name)1493     public abstract void removePermission(String name);
1494 
1495     /**
1496      * Grant a permission to an application which the application does not
1497      * already have.  The permission must have been requested by the application,
1498      * but as an optional permission.  If the application is not allowed to
1499      * hold the permission, a SecurityException is thrown.
1500      * @hide
1501      *
1502      * @param packageName The name of the package that the permission will be
1503      * granted to.
1504      * @param permissionName The name of the permission.
1505      */
grantPermission(String packageName, String permissionName)1506     public abstract void grantPermission(String packageName, String permissionName);
1507 
1508     /**
1509      * Revoke a permission that was previously granted by {@link #grantPermission}.
1510      * @hide
1511      *
1512      * @param packageName The name of the package that the permission will be
1513      * granted to.
1514      * @param permissionName The name of the permission.
1515      */
revokePermission(String packageName, String permissionName)1516     public abstract void revokePermission(String packageName, String permissionName);
1517 
1518     /**
1519      * Compare the signatures of two packages to determine if the same
1520      * signature appears in both of them.  If they do contain the same
1521      * signature, then they are allowed special privileges when working
1522      * with each other: they can share the same user-id, run instrumentation
1523      * against each other, etc.
1524      *
1525      * @param pkg1 First package name whose signature will be compared.
1526      * @param pkg2 Second package name whose signature will be compared.
1527      *
1528      * @return Returns an integer indicating whether all signatures on the
1529      * two packages match. The value is >= 0 ({@link #SIGNATURE_MATCH}) if
1530      * all signatures match or < 0 if there is not a match ({@link
1531      * #SIGNATURE_NO_MATCH} or {@link #SIGNATURE_UNKNOWN_PACKAGE}).
1532      *
1533      * @see #checkSignatures(int, int)
1534      * @see #SIGNATURE_MATCH
1535      * @see #SIGNATURE_NO_MATCH
1536      * @see #SIGNATURE_UNKNOWN_PACKAGE
1537      */
checkSignatures(String pkg1, String pkg2)1538     public abstract int checkSignatures(String pkg1, String pkg2);
1539 
1540     /**
1541      * Like {@link #checkSignatures(String, String)}, but takes UIDs of
1542      * the two packages to be checked.  This can be useful, for example,
1543      * when doing the check in an IPC, where the UID is the only identity
1544      * available.  It is functionally identical to determining the package
1545      * associated with the UIDs and checking their signatures.
1546      *
1547      * @param uid1 First UID whose signature will be compared.
1548      * @param uid2 Second UID whose signature will be compared.
1549      *
1550      * @return Returns an integer indicating whether all signatures on the
1551      * two packages match. The value is >= 0 ({@link #SIGNATURE_MATCH}) if
1552      * all signatures match or < 0 if there is not a match ({@link
1553      * #SIGNATURE_NO_MATCH} or {@link #SIGNATURE_UNKNOWN_PACKAGE}).
1554      *
1555      * @see #checkSignatures(String, String)
1556      * @see #SIGNATURE_MATCH
1557      * @see #SIGNATURE_NO_MATCH
1558      * @see #SIGNATURE_UNKNOWN_PACKAGE
1559      */
checkSignatures(int uid1, int uid2)1560     public abstract int checkSignatures(int uid1, int uid2);
1561 
1562     /**
1563      * Retrieve the names of all packages that are associated with a particular
1564      * user id.  In most cases, this will be a single package name, the package
1565      * that has been assigned that user id.  Where there are multiple packages
1566      * sharing the same user id through the "sharedUserId" mechanism, all
1567      * packages with that id will be returned.
1568      *
1569      * @param uid The user id for which you would like to retrieve the
1570      * associated packages.
1571      *
1572      * @return Returns an array of one or more packages assigned to the user
1573      * id, or null if there are no known packages with the given id.
1574      */
getPackagesForUid(int uid)1575     public abstract String[] getPackagesForUid(int uid);
1576 
1577     /**
1578      * Retrieve the official name associated with a user id.  This name is
1579      * guaranteed to never change, though it is possibly for the underlying
1580      * user id to be changed.  That is, if you are storing information about
1581      * user ids in persistent storage, you should use the string returned
1582      * by this function instead of the raw user-id.
1583      *
1584      * @param uid The user id for which you would like to retrieve a name.
1585      * @return Returns a unique name for the given user id, or null if the
1586      * user id is not currently assigned.
1587      */
getNameForUid(int uid)1588     public abstract String getNameForUid(int uid);
1589 
1590     /**
1591      * Return the user id associated with a shared user name. Multiple
1592      * applications can specify a shared user name in their manifest and thus
1593      * end up using a common uid. This might be used for new applications
1594      * that use an existing shared user name and need to know the uid of the
1595      * shared user.
1596      *
1597      * @param sharedUserName The shared user name whose uid is to be retrieved.
1598      * @return Returns the uid associated with the shared user, or  NameNotFoundException
1599      * if the shared user name is not being used by any installed packages
1600      * @hide
1601      */
getUidForSharedUser(String sharedUserName)1602     public abstract int getUidForSharedUser(String sharedUserName)
1603             throws NameNotFoundException;
1604 
1605     /**
1606      * Return a List of all application packages that are installed on the
1607      * device. If flag GET_UNINSTALLED_PACKAGES has been set, a list of all
1608      * applications including those deleted with DONT_DELETE_DATA(partially
1609      * installed apps with data directory) will be returned.
1610      *
1611      * @param flags Additional option flags. Use any combination of
1612      * {@link #GET_META_DATA}, {@link #GET_SHARED_LIBRARY_FILES},
1613      * {link #GET_UNINSTALLED_PACKAGES} to modify the data returned.
1614      *
1615      * @return A List of ApplicationInfo objects, one for each application that
1616      *         is installed on the device.  In the unlikely case of there being
1617      *         no installed applications, an empty list is returned.
1618      *         If flag GET_UNINSTALLED_PACKAGES is set, a list of all
1619      *         applications including those deleted with DONT_DELETE_DATA
1620      *         (partially installed apps with data directory) will be returned.
1621      *
1622      * @see #GET_META_DATA
1623      * @see #GET_SHARED_LIBRARY_FILES
1624      * @see #GET_UNINSTALLED_PACKAGES
1625      */
getInstalledApplications(int flags)1626     public abstract List<ApplicationInfo> getInstalledApplications(int flags);
1627 
1628     /**
1629      * Get a list of shared libraries that are available on the
1630      * system.
1631      *
1632      * @return An array of shared library names that are
1633      * available on the system, or null if none are installed.
1634      *
1635      */
getSystemSharedLibraryNames()1636     public abstract String[] getSystemSharedLibraryNames();
1637 
1638     /**
1639      * Get a list of features that are available on the
1640      * system.
1641      *
1642      * @return An array of FeatureInfo classes describing the features
1643      * that are available on the system, or null if there are none(!!).
1644      */
getSystemAvailableFeatures()1645     public abstract FeatureInfo[] getSystemAvailableFeatures();
1646 
1647     /**
1648      * Check whether the given feature name is one of the available
1649      * features as returned by {@link #getSystemAvailableFeatures()}.
1650      *
1651      * @return Returns true if the devices supports the feature, else
1652      * false.
1653      */
hasSystemFeature(String name)1654     public abstract boolean hasSystemFeature(String name);
1655 
1656     /**
1657      * Determine the best action to perform for a given Intent.  This is how
1658      * {@link Intent#resolveActivity} finds an activity if a class has not
1659      * been explicitly specified.
1660      *
1661      * <p><em>Note:</em> if using an implicit Intent (without an explicit ComponentName
1662      * specified), be sure to consider whether to set the {@link #MATCH_DEFAULT_ONLY}
1663      * only flag.  You need to do so to resolve the activity in the same way
1664      * that {@link android.content.Context#startActivity(Intent)} and
1665      * {@link android.content.Intent#resolveActivity(PackageManager)
1666      * Intent.resolveActivity(PackageManager)} do.</p>
1667      *
1668      * @param intent An intent containing all of the desired specification
1669      *               (action, data, type, category, and/or component).
1670      * @param flags Additional option flags.  The most important is
1671      * {@link #MATCH_DEFAULT_ONLY}, to limit the resolution to only
1672      * those activities that support the {@link android.content.Intent#CATEGORY_DEFAULT}.
1673      *
1674      * @return Returns a ResolveInfo containing the final activity intent that
1675      *         was determined to be the best action.  Returns null if no
1676      *         matching activity was found. If multiple matching activities are
1677      *         found and there is no default set, returns a ResolveInfo
1678      *         containing something else, such as the activity resolver.
1679      *
1680      * @see #MATCH_DEFAULT_ONLY
1681      * @see #GET_INTENT_FILTERS
1682      * @see #GET_RESOLVED_FILTER
1683      */
resolveActivity(Intent intent, int flags)1684     public abstract ResolveInfo resolveActivity(Intent intent, int flags);
1685 
1686     /**
1687      * Retrieve all activities that can be performed for the given intent.
1688      *
1689      * @param intent The desired intent as per resolveActivity().
1690      * @param flags Additional option flags.  The most important is
1691      * {@link #MATCH_DEFAULT_ONLY}, to limit the resolution to only
1692      * those activities that support the {@link android.content.Intent#CATEGORY_DEFAULT}.
1693      *
1694      * @return A List&lt;ResolveInfo&gt; containing one entry for each matching
1695      *         Activity. These are ordered from best to worst match -- that
1696      *         is, the first item in the list is what is returned by
1697      *         {@link #resolveActivity}.  If there are no matching activities, an empty
1698      *         list is returned.
1699      *
1700      * @see #MATCH_DEFAULT_ONLY
1701      * @see #GET_INTENT_FILTERS
1702      * @see #GET_RESOLVED_FILTER
1703      */
queryIntentActivities(Intent intent, int flags)1704     public abstract List<ResolveInfo> queryIntentActivities(Intent intent,
1705             int flags);
1706 
1707     /**
1708      * Retrieve a set of activities that should be presented to the user as
1709      * similar options.  This is like {@link #queryIntentActivities}, except it
1710      * also allows you to supply a list of more explicit Intents that you would
1711      * like to resolve to particular options, and takes care of returning the
1712      * final ResolveInfo list in a reasonable order, with no duplicates, based
1713      * on those inputs.
1714      *
1715      * @param caller The class name of the activity that is making the
1716      *               request.  This activity will never appear in the output
1717      *               list.  Can be null.
1718      * @param specifics An array of Intents that should be resolved to the
1719      *                  first specific results.  Can be null.
1720      * @param intent The desired intent as per resolveActivity().
1721      * @param flags Additional option flags.  The most important is
1722      * {@link #MATCH_DEFAULT_ONLY}, to limit the resolution to only
1723      * those activities that support the {@link android.content.Intent#CATEGORY_DEFAULT}.
1724      *
1725      * @return A List&lt;ResolveInfo&gt; containing one entry for each matching
1726      *         Activity. These are ordered first by all of the intents resolved
1727      *         in <var>specifics</var> and then any additional activities that
1728      *         can handle <var>intent</var> but did not get included by one of
1729      *         the <var>specifics</var> intents.  If there are no matching
1730      *         activities, an empty list is returned.
1731      *
1732      * @see #MATCH_DEFAULT_ONLY
1733      * @see #GET_INTENT_FILTERS
1734      * @see #GET_RESOLVED_FILTER
1735      */
queryIntentActivityOptions( ComponentName caller, Intent[] specifics, Intent intent, int flags)1736     public abstract List<ResolveInfo> queryIntentActivityOptions(
1737             ComponentName caller, Intent[] specifics, Intent intent, int flags);
1738 
1739     /**
1740      * Retrieve all receivers that can handle a broadcast of the given intent.
1741      *
1742      * @param intent The desired intent as per resolveActivity().
1743      * @param flags Additional option flags.
1744      *
1745      * @return A List&lt;ResolveInfo&gt; containing one entry for each matching
1746      *         Receiver. These are ordered from first to last in priority.  If
1747      *         there are no matching receivers, an empty list is returned.
1748      *
1749      * @see #MATCH_DEFAULT_ONLY
1750      * @see #GET_INTENT_FILTERS
1751      * @see #GET_RESOLVED_FILTER
1752      */
queryBroadcastReceivers(Intent intent, int flags)1753     public abstract List<ResolveInfo> queryBroadcastReceivers(Intent intent,
1754             int flags);
1755 
1756     /**
1757      * Determine the best service to handle for a given Intent.
1758      *
1759      * @param intent An intent containing all of the desired specification
1760      *               (action, data, type, category, and/or component).
1761      * @param flags Additional option flags.
1762      *
1763      * @return Returns a ResolveInfo containing the final service intent that
1764      *         was determined to be the best action.  Returns null if no
1765      *         matching service was found.
1766      *
1767      * @see #GET_INTENT_FILTERS
1768      * @see #GET_RESOLVED_FILTER
1769      */
resolveService(Intent intent, int flags)1770     public abstract ResolveInfo resolveService(Intent intent, int flags);
1771 
1772     /**
1773      * Retrieve all services that can match the given intent.
1774      *
1775      * @param intent The desired intent as per resolveService().
1776      * @param flags Additional option flags.
1777      *
1778      * @return A List&lt;ResolveInfo&gt; containing one entry for each matching
1779      *         ServiceInfo. These are ordered from best to worst match -- that
1780      *         is, the first item in the list is what is returned by
1781      *         resolveService().  If there are no matching services, an empty
1782      *         list is returned.
1783      *
1784      * @see #GET_INTENT_FILTERS
1785      * @see #GET_RESOLVED_FILTER
1786      */
queryIntentServices(Intent intent, int flags)1787     public abstract List<ResolveInfo> queryIntentServices(Intent intent,
1788             int flags);
1789 
1790     /**
1791      * Find a single content provider by its base path name.
1792      *
1793      * @param name The name of the provider to find.
1794      * @param flags Additional option flags.  Currently should always be 0.
1795      *
1796      * @return ContentProviderInfo Information about the provider, if found,
1797      *         else null.
1798      */
resolveContentProvider(String name, int flags)1799     public abstract ProviderInfo resolveContentProvider(String name,
1800             int flags);
1801 
1802     /**
1803      * Retrieve content provider information.
1804      *
1805      * <p><em>Note: unlike most other methods, an empty result set is indicated
1806      * by a null return instead of an empty list.</em>
1807      *
1808      * @param processName If non-null, limits the returned providers to only
1809      *                    those that are hosted by the given process.  If null,
1810      *                    all content providers are returned.
1811      * @param uid If <var>processName</var> is non-null, this is the required
1812      *        uid owning the requested content providers.
1813      * @param flags Additional option flags.  Currently should always be 0.
1814      *
1815      * @return A List&lt;ContentProviderInfo&gt; containing one entry for each
1816      *         content provider either patching <var>processName</var> or, if
1817      *         <var>processName</var> is null, all known content providers.
1818      *         <em>If there are no matching providers, null is returned.</em>
1819      */
queryContentProviders( String processName, int uid, int flags)1820     public abstract List<ProviderInfo> queryContentProviders(
1821             String processName, int uid, int flags);
1822 
1823     /**
1824      * Retrieve all of the information we know about a particular
1825      * instrumentation class.
1826      *
1827      * <p>Throws {@link NameNotFoundException} if instrumentation with the
1828      * given class name can not be found on the system.
1829      *
1830      * @param className The full name (i.e.
1831      *                  com.google.apps.contacts.InstrumentList) of an
1832      *                  Instrumentation class.
1833      * @param flags Additional option flags.  Currently should always be 0.
1834      *
1835      * @return InstrumentationInfo containing information about the
1836      *         instrumentation.
1837      */
getInstrumentationInfo( ComponentName className, int flags)1838     public abstract InstrumentationInfo getInstrumentationInfo(
1839             ComponentName className, int flags) throws NameNotFoundException;
1840 
1841     /**
1842      * Retrieve information about available instrumentation code.  May be used
1843      * to retrieve either all instrumentation code, or only the code targeting
1844      * a particular package.
1845      *
1846      * @param targetPackage If null, all instrumentation is returned; only the
1847      *                      instrumentation targeting this package name is
1848      *                      returned.
1849      * @param flags Additional option flags.  Currently should always be 0.
1850      *
1851      * @return A List&lt;InstrumentationInfo&gt; containing one entry for each
1852      *         matching available Instrumentation.  Returns an empty list if
1853      *         there is no instrumentation available for the given package.
1854      */
queryInstrumentation( String targetPackage, int flags)1855     public abstract List<InstrumentationInfo> queryInstrumentation(
1856             String targetPackage, int flags);
1857 
1858     /**
1859      * Retrieve an image from a package.  This is a low-level API used by
1860      * the various package manager info structures (such as
1861      * {@link ComponentInfo} to implement retrieval of their associated
1862      * icon.
1863      *
1864      * @param packageName The name of the package that this icon is coming from.
1865      * Can not be null.
1866      * @param resid The resource identifier of the desired image.  Can not be 0.
1867      * @param appInfo Overall information about <var>packageName</var>.  This
1868      * may be null, in which case the application information will be retrieved
1869      * for you if needed; if you already have this information around, it can
1870      * be much more efficient to supply it here.
1871      *
1872      * @return Returns a Drawable holding the requested image.  Returns null if
1873      * an image could not be found for any reason.
1874      */
getDrawable(String packageName, int resid, ApplicationInfo appInfo)1875     public abstract Drawable getDrawable(String packageName, int resid,
1876             ApplicationInfo appInfo);
1877 
1878     /**
1879      * Retrieve the icon associated with an activity.  Given the full name of
1880      * an activity, retrieves the information about it and calls
1881      * {@link ComponentInfo#loadIcon ComponentInfo.loadIcon()} to return its icon.
1882      * If the activity can not be found, NameNotFoundException is thrown.
1883      *
1884      * @param activityName Name of the activity whose icon is to be retrieved.
1885      *
1886      * @return Returns the image of the icon, or the default activity icon if
1887      * it could not be found.  Does not return null.
1888      * @throws NameNotFoundException Thrown if the resources for the given
1889      * activity could not be loaded.
1890      *
1891      * @see #getActivityIcon(Intent)
1892      */
getActivityIcon(ComponentName activityName)1893     public abstract Drawable getActivityIcon(ComponentName activityName)
1894             throws NameNotFoundException;
1895 
1896     /**
1897      * Retrieve the icon associated with an Intent.  If intent.getClassName() is
1898      * set, this simply returns the result of
1899      * getActivityIcon(intent.getClassName()).  Otherwise it resolves the intent's
1900      * component and returns the icon associated with the resolved component.
1901      * If intent.getClassName() can not be found or the Intent can not be resolved
1902      * to a component, NameNotFoundException is thrown.
1903      *
1904      * @param intent The intent for which you would like to retrieve an icon.
1905      *
1906      * @return Returns the image of the icon, or the default activity icon if
1907      * it could not be found.  Does not return null.
1908      * @throws NameNotFoundException Thrown if the resources for application
1909      * matching the given intent could not be loaded.
1910      *
1911      * @see #getActivityIcon(ComponentName)
1912      */
getActivityIcon(Intent intent)1913     public abstract Drawable getActivityIcon(Intent intent)
1914             throws NameNotFoundException;
1915 
1916     /**
1917      * Return the generic icon for an activity that is used when no specific
1918      * icon is defined.
1919      *
1920      * @return Drawable Image of the icon.
1921      */
getDefaultActivityIcon()1922     public abstract Drawable getDefaultActivityIcon();
1923 
1924     /**
1925      * Retrieve the icon associated with an application.  If it has not defined
1926      * an icon, the default app icon is returned.  Does not return null.
1927      *
1928      * @param info Information about application being queried.
1929      *
1930      * @return Returns the image of the icon, or the default application icon
1931      * if it could not be found.
1932      *
1933      * @see #getApplicationIcon(String)
1934      */
getApplicationIcon(ApplicationInfo info)1935     public abstract Drawable getApplicationIcon(ApplicationInfo info);
1936 
1937     /**
1938      * Retrieve the icon associated with an application.  Given the name of the
1939      * application's package, retrieves the information about it and calls
1940      * getApplicationIcon() to return its icon. If the application can not be
1941      * found, NameNotFoundException is thrown.
1942      *
1943      * @param packageName Name of the package whose application icon is to be
1944      *                    retrieved.
1945      *
1946      * @return Returns the image of the icon, or the default application icon
1947      * if it could not be found.  Does not return null.
1948      * @throws NameNotFoundException Thrown if the resources for the given
1949      * application could not be loaded.
1950      *
1951      * @see #getApplicationIcon(ApplicationInfo)
1952      */
getApplicationIcon(String packageName)1953     public abstract Drawable getApplicationIcon(String packageName)
1954             throws NameNotFoundException;
1955 
1956     /**
1957      * Retrieve the logo associated with an activity.  Given the full name of
1958      * an activity, retrieves the information about it and calls
1959      * {@link ComponentInfo#loadLogo ComponentInfo.loadLogo()} to return its logo.
1960      * If the activity can not be found, NameNotFoundException is thrown.
1961      *
1962      * @param activityName Name of the activity whose logo is to be retrieved.
1963      *
1964      * @return Returns the image of the logo or null if the activity has no
1965      * logo specified.
1966      *
1967      * @throws NameNotFoundException Thrown if the resources for the given
1968      * activity could not be loaded.
1969      *
1970      * @see #getActivityLogo(Intent)
1971      */
getActivityLogo(ComponentName activityName)1972     public abstract Drawable getActivityLogo(ComponentName activityName)
1973             throws NameNotFoundException;
1974 
1975     /**
1976      * Retrieve the logo associated with an Intent.  If intent.getClassName() is
1977      * set, this simply returns the result of
1978      * getActivityLogo(intent.getClassName()).  Otherwise it resolves the intent's
1979      * component and returns the logo associated with the resolved component.
1980      * If intent.getClassName() can not be found or the Intent can not be resolved
1981      * to a component, NameNotFoundException is thrown.
1982      *
1983      * @param intent The intent for which you would like to retrieve a logo.
1984      *
1985      * @return Returns the image of the logo, or null if the activity has no
1986      * logo specified.
1987      *
1988      * @throws NameNotFoundException Thrown if the resources for application
1989      * matching the given intent could not be loaded.
1990      *
1991      * @see #getActivityLogo(ComponentName)
1992      */
getActivityLogo(Intent intent)1993     public abstract Drawable getActivityLogo(Intent intent)
1994             throws NameNotFoundException;
1995 
1996     /**
1997      * Retrieve the logo associated with an application.  If it has not specified
1998      * a logo, this method returns null.
1999      *
2000      * @param info Information about application being queried.
2001      *
2002      * @return Returns the image of the logo, or null if no logo is specified
2003      * by the application.
2004      *
2005      * @see #getApplicationLogo(String)
2006      */
getApplicationLogo(ApplicationInfo info)2007     public abstract Drawable getApplicationLogo(ApplicationInfo info);
2008 
2009     /**
2010      * Retrieve the logo associated with an application.  Given the name of the
2011      * application's package, retrieves the information about it and calls
2012      * getApplicationLogo() to return its logo. If the application can not be
2013      * found, NameNotFoundException is thrown.
2014      *
2015      * @param packageName Name of the package whose application logo is to be
2016      *                    retrieved.
2017      *
2018      * @return Returns the image of the logo, or null if no application logo
2019      * has been specified.
2020      *
2021      * @throws NameNotFoundException Thrown if the resources for the given
2022      * application could not be loaded.
2023      *
2024      * @see #getApplicationLogo(ApplicationInfo)
2025      */
getApplicationLogo(String packageName)2026     public abstract Drawable getApplicationLogo(String packageName)
2027             throws NameNotFoundException;
2028 
2029     /**
2030      * Retrieve text from a package.  This is a low-level API used by
2031      * the various package manager info structures (such as
2032      * {@link ComponentInfo} to implement retrieval of their associated
2033      * labels and other text.
2034      *
2035      * @param packageName The name of the package that this text is coming from.
2036      * Can not be null.
2037      * @param resid The resource identifier of the desired text.  Can not be 0.
2038      * @param appInfo Overall information about <var>packageName</var>.  This
2039      * may be null, in which case the application information will be retrieved
2040      * for you if needed; if you already have this information around, it can
2041      * be much more efficient to supply it here.
2042      *
2043      * @return Returns a CharSequence holding the requested text.  Returns null
2044      * if the text could not be found for any reason.
2045      */
getText(String packageName, int resid, ApplicationInfo appInfo)2046     public abstract CharSequence getText(String packageName, int resid,
2047             ApplicationInfo appInfo);
2048 
2049     /**
2050      * Retrieve an XML file from a package.  This is a low-level API used to
2051      * retrieve XML meta data.
2052      *
2053      * @param packageName The name of the package that this xml is coming from.
2054      * Can not be null.
2055      * @param resid The resource identifier of the desired xml.  Can not be 0.
2056      * @param appInfo Overall information about <var>packageName</var>.  This
2057      * may be null, in which case the application information will be retrieved
2058      * for you if needed; if you already have this information around, it can
2059      * be much more efficient to supply it here.
2060      *
2061      * @return Returns an XmlPullParser allowing you to parse out the XML
2062      * data.  Returns null if the xml resource could not be found for any
2063      * reason.
2064      */
getXml(String packageName, int resid, ApplicationInfo appInfo)2065     public abstract XmlResourceParser getXml(String packageName, int resid,
2066             ApplicationInfo appInfo);
2067 
2068     /**
2069      * Return the label to use for this application.
2070      *
2071      * @return Returns the label associated with this application, or null if
2072      * it could not be found for any reason.
2073      * @param info The application to get the label of
2074      */
getApplicationLabel(ApplicationInfo info)2075     public abstract CharSequence getApplicationLabel(ApplicationInfo info);
2076 
2077     /**
2078      * Retrieve the resources associated with an activity.  Given the full
2079      * name of an activity, retrieves the information about it and calls
2080      * getResources() to return its application's resources.  If the activity
2081      * can not be found, NameNotFoundException is thrown.
2082      *
2083      * @param activityName Name of the activity whose resources are to be
2084      *                     retrieved.
2085      *
2086      * @return Returns the application's Resources.
2087      * @throws NameNotFoundException Thrown if the resources for the given
2088      * application could not be loaded.
2089      *
2090      * @see #getResourcesForApplication(ApplicationInfo)
2091      */
getResourcesForActivity(ComponentName activityName)2092     public abstract Resources getResourcesForActivity(ComponentName activityName)
2093             throws NameNotFoundException;
2094 
2095     /**
2096      * Retrieve the resources for an application.  Throws NameNotFoundException
2097      * if the package is no longer installed.
2098      *
2099      * @param app Information about the desired application.
2100      *
2101      * @return Returns the application's Resources.
2102      * @throws NameNotFoundException Thrown if the resources for the given
2103      * application could not be loaded (most likely because it was uninstalled).
2104      */
getResourcesForApplication(ApplicationInfo app)2105     public abstract Resources getResourcesForApplication(ApplicationInfo app)
2106             throws NameNotFoundException;
2107 
2108     /**
2109      * Retrieve the resources associated with an application.  Given the full
2110      * package name of an application, retrieves the information about it and
2111      * calls getResources() to return its application's resources.  If the
2112      * appPackageName can not be found, NameNotFoundException is thrown.
2113      *
2114      * @param appPackageName Package name of the application whose resources
2115      *                       are to be retrieved.
2116      *
2117      * @return Returns the application's Resources.
2118      * @throws NameNotFoundException Thrown if the resources for the given
2119      * application could not be loaded.
2120      *
2121      * @see #getResourcesForApplication(ApplicationInfo)
2122      */
getResourcesForApplication(String appPackageName)2123     public abstract Resources getResourcesForApplication(String appPackageName)
2124             throws NameNotFoundException;
2125 
2126     /**
2127      * Retrieve overall information about an application package defined
2128      * in a package archive file
2129      *
2130      * @param archiveFilePath The path to the archive file
2131      * @param flags Additional option flags. Use any combination of
2132      * {@link #GET_ACTIVITIES},
2133      * {@link #GET_GIDS},
2134      * {@link #GET_CONFIGURATIONS},
2135      * {@link #GET_INSTRUMENTATION},
2136      * {@link #GET_PERMISSIONS},
2137      * {@link #GET_PROVIDERS},
2138      * {@link #GET_RECEIVERS},
2139      * {@link #GET_SERVICES},
2140      * {@link #GET_SIGNATURES}, to modify the data returned.
2141      *
2142      * @return Returns the information about the package. Returns
2143      * null if the package could not be successfully parsed.
2144      *
2145      * @see #GET_ACTIVITIES
2146      * @see #GET_GIDS
2147      * @see #GET_CONFIGURATIONS
2148      * @see #GET_INSTRUMENTATION
2149      * @see #GET_PERMISSIONS
2150      * @see #GET_PROVIDERS
2151      * @see #GET_RECEIVERS
2152      * @see #GET_SERVICES
2153      * @see #GET_SIGNATURES
2154      *
2155      */
getPackageArchiveInfo(String archiveFilePath, int flags)2156     public PackageInfo getPackageArchiveInfo(String archiveFilePath, int flags) {
2157         PackageParser packageParser = new PackageParser(archiveFilePath);
2158         DisplayMetrics metrics = new DisplayMetrics();
2159         metrics.setToDefaults();
2160         final File sourceFile = new File(archiveFilePath);
2161         PackageParser.Package pkg = packageParser.parsePackage(
2162                 sourceFile, archiveFilePath, metrics, 0);
2163         if (pkg == null) {
2164             return null;
2165         }
2166         if ((flags & GET_SIGNATURES) != 0) {
2167             packageParser.collectCertificates(pkg, 0);
2168         }
2169         return PackageParser.generatePackageInfo(pkg, null, flags, 0, 0, null, false,
2170                 COMPONENT_ENABLED_STATE_DEFAULT);
2171     }
2172 
2173     /**
2174      * @hide
2175      *
2176      * Install a package. Since this may take a little while, the result will
2177      * be posted back to the given observer.  An installation will fail if the calling context
2178      * lacks the {@link android.Manifest.permission#INSTALL_PACKAGES} permission, if the
2179      * package named in the package file's manifest is already installed, or if there's no space
2180      * available on the device.
2181      *
2182      * @param packageURI The location of the package file to install.  This can be a 'file:' or a
2183      * 'content:' URI.
2184      * @param observer An observer callback to get notified when the package installation is
2185      * complete. {@link IPackageInstallObserver#packageInstalled(String, int)} will be
2186      * called when that happens.  observer may be null to indicate that no callback is desired.
2187      * @param flags - possible values: {@link #INSTALL_FORWARD_LOCK},
2188      * {@link #INSTALL_REPLACE_EXISTING}, {@link #INSTALL_ALLOW_TEST}.
2189      * @param installerPackageName Optional package name of the application that is performing the
2190      * installation. This identifies which market the package came from.
2191      */
installPackage( Uri packageURI, IPackageInstallObserver observer, int flags, String installerPackageName)2192     public abstract void installPackage(
2193             Uri packageURI, IPackageInstallObserver observer, int flags,
2194             String installerPackageName);
2195 
2196     /**
2197      * Similar to
2198      * {@link #installPackage(Uri, IPackageInstallObserver, int, String)} but
2199      * with an extra verification file provided.
2200      *
2201      * @param packageURI The location of the package file to install. This can
2202      *            be a 'file:' or a 'content:' URI.
2203      * @param observer An observer callback to get notified when the package
2204      *            installation is complete.
2205      *            {@link IPackageInstallObserver#packageInstalled(String, int)}
2206      *            will be called when that happens. observer may be null to
2207      *            indicate that no callback is desired.
2208      * @param flags - possible values: {@link #INSTALL_FORWARD_LOCK},
2209      *            {@link #INSTALL_REPLACE_EXISTING}, {@link #INSTALL_ALLOW_TEST}
2210      *            .
2211      * @param installerPackageName Optional package name of the application that
2212      *            is performing the installation. This identifies which market
2213      *            the package came from.
2214      * @param verificationURI The location of the supplementary verification
2215      *            file. This can be a 'file:' or a 'content:' URI. May be
2216      *            {@code null}.
2217      * @param manifestDigest an object that holds the digest of the package
2218      *            which can be used to verify ownership. May be {@code null}.
2219      * @param encryptionParams if the package to be installed is encrypted,
2220      *            these parameters describing the encryption and authentication
2221      *            used. May be {@code null}.
2222      * @hide
2223      */
installPackageWithVerification(Uri packageURI, IPackageInstallObserver observer, int flags, String installerPackageName, Uri verificationURI, ManifestDigest manifestDigest, ContainerEncryptionParams encryptionParams)2224     public abstract void installPackageWithVerification(Uri packageURI,
2225             IPackageInstallObserver observer, int flags, String installerPackageName,
2226             Uri verificationURI, ManifestDigest manifestDigest,
2227             ContainerEncryptionParams encryptionParams);
2228 
2229     /**
2230      * Allows a package listening to the
2231      * {@link Intent#ACTION_PACKAGE_NEEDS_VERIFICATION package verification
2232      * broadcast} to respond to the package manager. The response must include
2233      * the {@code verificationCode} which is one of
2234      * {@link PackageManager#VERIFICATION_ALLOW} or
2235      * {@link PackageManager#VERIFICATION_REJECT}.
2236      *
2237      * @param id pending package identifier as passed via the
2238      *            {@link PackageManager#EXTRA_VERIFICATION_ID} Intent extra
2239      * @param verificationCode either {@link PackageManager#VERIFICATION_ALLOW}
2240      *            or {@link PackageManager#VERIFICATION_REJECT}.
2241      */
verifyPendingInstall(int id, int verificationCode)2242     public abstract void verifyPendingInstall(int id, int verificationCode);
2243 
2244     /**
2245      * Change the installer associated with a given package.  There are limitations
2246      * on how the installer package can be changed; in particular:
2247      * <ul>
2248      * <li> A SecurityException will be thrown if <var>installerPackageName</var>
2249      * is not signed with the same certificate as the calling application.
2250      * <li> A SecurityException will be thrown if <var>targetPackage</var> already
2251      * has an installer package, and that installer package is not signed with
2252      * the same certificate as the calling application.
2253      * </ul>
2254      *
2255      * @param targetPackage The installed package whose installer will be changed.
2256      * @param installerPackageName The package name of the new installer.  May be
2257      * null to clear the association.
2258      */
setInstallerPackageName(String targetPackage, String installerPackageName)2259     public abstract void setInstallerPackageName(String targetPackage,
2260             String installerPackageName);
2261 
2262     /**
2263      * Attempts to delete a package.  Since this may take a little while, the result will
2264      * be posted back to the given observer.  A deletion will fail if the calling context
2265      * lacks the {@link android.Manifest.permission#DELETE_PACKAGES} permission, if the
2266      * named package cannot be found, or if the named package is a "system package".
2267      * (TODO: include pointer to documentation on "system packages")
2268      *
2269      * @param packageName The name of the package to delete
2270      * @param observer An observer callback to get notified when the package deletion is
2271      * complete. {@link android.content.pm.IPackageDeleteObserver#packageDeleted(boolean)} will be
2272      * called when that happens.  observer may be null to indicate that no callback is desired.
2273      * @param flags - possible values: {@link #DONT_DELETE_DATA}
2274      *
2275      * @hide
2276      */
deletePackage( String packageName, IPackageDeleteObserver observer, int flags)2277     public abstract void deletePackage(
2278             String packageName, IPackageDeleteObserver observer, int flags);
2279 
2280     /**
2281      * Retrieve the package name of the application that installed a package. This identifies
2282      * which market the package came from.
2283      *
2284      * @param packageName The name of the package to query
2285      */
getInstallerPackageName(String packageName)2286     public abstract String getInstallerPackageName(String packageName);
2287 
2288     /**
2289      * Attempts to clear the user data directory of an application.
2290      * Since this may take a little while, the result will
2291      * be posted back to the given observer.  A deletion will fail if the
2292      * named package cannot be found, or if the named package is a "system package".
2293      *
2294      * @param packageName The name of the package
2295      * @param observer An observer callback to get notified when the operation is finished
2296      * {@link android.content.pm.IPackageDataObserver#onRemoveCompleted(String, boolean)}
2297      * will be called when that happens.  observer may be null to indicate that
2298      * no callback is desired.
2299      *
2300      * @hide
2301      */
clearApplicationUserData(String packageName, IPackageDataObserver observer)2302     public abstract void clearApplicationUserData(String packageName,
2303             IPackageDataObserver observer);
2304     /**
2305      * Attempts to delete the cache files associated with an application.
2306      * Since this may take a little while, the result will
2307      * be posted back to the given observer.  A deletion will fail if the calling context
2308      * lacks the {@link android.Manifest.permission#DELETE_CACHE_FILES} permission, if the
2309      * named package cannot be found, or if the named package is a "system package".
2310      *
2311      * @param packageName The name of the package to delete
2312      * @param observer An observer callback to get notified when the cache file deletion
2313      * is complete.
2314      * {@link android.content.pm.IPackageDataObserver#onRemoveCompleted(String, boolean)}
2315      * will be called when that happens.  observer may be null to indicate that
2316      * no callback is desired.
2317      *
2318      * @hide
2319      */
deleteApplicationCacheFiles(String packageName, IPackageDataObserver observer)2320     public abstract void deleteApplicationCacheFiles(String packageName,
2321             IPackageDataObserver observer);
2322 
2323     /**
2324      * Free storage by deleting LRU sorted list of cache files across
2325      * all applications. If the currently available free storage
2326      * on the device is greater than or equal to the requested
2327      * free storage, no cache files are cleared. If the currently
2328      * available storage on the device is less than the requested
2329      * free storage, some or all of the cache files across
2330      * all applications are deleted (based on last accessed time)
2331      * to increase the free storage space on the device to
2332      * the requested value. There is no guarantee that clearing all
2333      * the cache files from all applications will clear up
2334      * enough storage to achieve the desired value.
2335      * @param freeStorageSize The number of bytes of storage to be
2336      * freed by the system. Say if freeStorageSize is XX,
2337      * and the current free storage is YY,
2338      * if XX is less than YY, just return. if not free XX-YY number
2339      * of bytes if possible.
2340      * @param observer call back used to notify when
2341      * the operation is completed
2342      *
2343      * @hide
2344      */
freeStorageAndNotify(long freeStorageSize, IPackageDataObserver observer)2345     public abstract void freeStorageAndNotify(long freeStorageSize, IPackageDataObserver observer);
2346 
2347     /**
2348      * Free storage by deleting LRU sorted list of cache files across
2349      * all applications. If the currently available free storage
2350      * on the device is greater than or equal to the requested
2351      * free storage, no cache files are cleared. If the currently
2352      * available storage on the device is less than the requested
2353      * free storage, some or all of the cache files across
2354      * all applications are deleted (based on last accessed time)
2355      * to increase the free storage space on the device to
2356      * the requested value. There is no guarantee that clearing all
2357      * the cache files from all applications will clear up
2358      * enough storage to achieve the desired value.
2359      * @param freeStorageSize The number of bytes of storage to be
2360      * freed by the system. Say if freeStorageSize is XX,
2361      * and the current free storage is YY,
2362      * if XX is less than YY, just return. if not free XX-YY number
2363      * of bytes if possible.
2364      * @param pi IntentSender call back used to
2365      * notify when the operation is completed.May be null
2366      * to indicate that no call back is desired.
2367      *
2368      * @hide
2369      */
freeStorage(long freeStorageSize, IntentSender pi)2370     public abstract void freeStorage(long freeStorageSize, IntentSender pi);
2371 
2372     /**
2373      * Retrieve the size information for a package.
2374      * Since this may take a little while, the result will
2375      * be posted back to the given observer.  The calling context
2376      * should have the {@link android.Manifest.permission#GET_PACKAGE_SIZE} permission.
2377      *
2378      * @param packageName The name of the package whose size information is to be retrieved
2379      * @param observer An observer callback to get notified when the operation
2380      * is complete.
2381      * {@link android.content.pm.IPackageStatsObserver#onGetStatsCompleted(PackageStats, boolean)}
2382      * The observer's callback is invoked with a PackageStats object(containing the
2383      * code, data and cache sizes of the package) and a boolean value representing
2384      * the status of the operation. observer may be null to indicate that
2385      * no callback is desired.
2386      *
2387      * @hide
2388      */
getPackageSizeInfo(String packageName, IPackageStatsObserver observer)2389     public abstract void getPackageSizeInfo(String packageName,
2390             IPackageStatsObserver observer);
2391 
2392     /**
2393      * @deprecated This function no longer does anything; it was an old
2394      * approach to managing preferred activities, which has been superceeded
2395      * (and conflicts with) the modern activity-based preferences.
2396      */
2397     @Deprecated
addPackageToPreferred(String packageName)2398     public abstract void addPackageToPreferred(String packageName);
2399 
2400     /**
2401      * @deprecated This function no longer does anything; it was an old
2402      * approach to managing preferred activities, which has been superceeded
2403      * (and conflicts with) the modern activity-based preferences.
2404      */
2405     @Deprecated
removePackageFromPreferred(String packageName)2406     public abstract void removePackageFromPreferred(String packageName);
2407 
2408     /**
2409      * Retrieve the list of all currently configured preferred packages.  The
2410      * first package on the list is the most preferred, the last is the
2411      * least preferred.
2412      *
2413      * @param flags Additional option flags. Use any combination of
2414      * {@link #GET_ACTIVITIES},
2415      * {@link #GET_GIDS},
2416      * {@link #GET_CONFIGURATIONS},
2417      * {@link #GET_INSTRUMENTATION},
2418      * {@link #GET_PERMISSIONS},
2419      * {@link #GET_PROVIDERS},
2420      * {@link #GET_RECEIVERS},
2421      * {@link #GET_SERVICES},
2422      * {@link #GET_SIGNATURES}, to modify the data returned.
2423      *
2424      * @return Returns a list of PackageInfo objects describing each
2425      * preferred application, in order of preference.
2426      *
2427      * @see #GET_ACTIVITIES
2428      * @see #GET_GIDS
2429      * @see #GET_CONFIGURATIONS
2430      * @see #GET_INSTRUMENTATION
2431      * @see #GET_PERMISSIONS
2432      * @see #GET_PROVIDERS
2433      * @see #GET_RECEIVERS
2434      * @see #GET_SERVICES
2435      * @see #GET_SIGNATURES
2436      */
getPreferredPackages(int flags)2437     public abstract List<PackageInfo> getPreferredPackages(int flags);
2438 
2439     /**
2440      * @deprecated This is a protected API that should not have been available
2441      * to third party applications.  It is the platform's responsibility for
2442      * assigning preferred activities and this can not be directly modified.
2443      *
2444      * Add a new preferred activity mapping to the system.  This will be used
2445      * to automatically select the given activity component when
2446      * {@link Context#startActivity(Intent) Context.startActivity()} finds
2447      * multiple matching activities and also matches the given filter.
2448      *
2449      * @param filter The set of intents under which this activity will be
2450      * made preferred.
2451      * @param match The IntentFilter match category that this preference
2452      * applies to.
2453      * @param set The set of activities that the user was picking from when
2454      * this preference was made.
2455      * @param activity The component name of the activity that is to be
2456      * preferred.
2457      */
2458     @Deprecated
addPreferredActivity(IntentFilter filter, int match, ComponentName[] set, ComponentName activity)2459     public abstract void addPreferredActivity(IntentFilter filter, int match,
2460             ComponentName[] set, ComponentName activity);
2461 
2462     /**
2463      * @deprecated This is a protected API that should not have been available
2464      * to third party applications.  It is the platform's responsibility for
2465      * assigning preferred activities and this can not be directly modified.
2466      *
2467      * Replaces an existing preferred activity mapping to the system, and if that were not present
2468      * adds a new preferred activity.  This will be used
2469      * to automatically select the given activity component when
2470      * {@link Context#startActivity(Intent) Context.startActivity()} finds
2471      * multiple matching activities and also matches the given filter.
2472      *
2473      * @param filter The set of intents under which this activity will be
2474      * made preferred.
2475      * @param match The IntentFilter match category that this preference
2476      * applies to.
2477      * @param set The set of activities that the user was picking from when
2478      * this preference was made.
2479      * @param activity The component name of the activity that is to be
2480      * preferred.
2481      * @hide
2482      */
2483     @Deprecated
replacePreferredActivity(IntentFilter filter, int match, ComponentName[] set, ComponentName activity)2484     public abstract void replacePreferredActivity(IntentFilter filter, int match,
2485             ComponentName[] set, ComponentName activity);
2486 
2487     /**
2488      * Remove all preferred activity mappings, previously added with
2489      * {@link #addPreferredActivity}, from the
2490      * system whose activities are implemented in the given package name.
2491      * An application can only clear its own package(s).
2492      *
2493      * @param packageName The name of the package whose preferred activity
2494      * mappings are to be removed.
2495      */
clearPackagePreferredActivities(String packageName)2496     public abstract void clearPackagePreferredActivities(String packageName);
2497 
2498     /**
2499      * Retrieve all preferred activities, previously added with
2500      * {@link #addPreferredActivity}, that are
2501      * currently registered with the system.
2502      *
2503      * @param outFilters A list in which to place the filters of all of the
2504      * preferred activities, or null for none.
2505      * @param outActivities A list in which to place the component names of
2506      * all of the preferred activities, or null for none.
2507      * @param packageName An option package in which you would like to limit
2508      * the list.  If null, all activities will be returned; if non-null, only
2509      * those activities in the given package are returned.
2510      *
2511      * @return Returns the total number of registered preferred activities
2512      * (the number of distinct IntentFilter records, not the number of unique
2513      * activity components) that were found.
2514      */
getPreferredActivities(List<IntentFilter> outFilters, List<ComponentName> outActivities, String packageName)2515     public abstract int getPreferredActivities(List<IntentFilter> outFilters,
2516             List<ComponentName> outActivities, String packageName);
2517 
2518     /**
2519      * Set the enabled setting for a package component (activity, receiver, service, provider).
2520      * This setting will override any enabled state which may have been set by the component in its
2521      * manifest.
2522      *
2523      * @param componentName The component to enable
2524      * @param newState The new enabled state for the component.  The legal values for this state
2525      *                 are:
2526      *                   {@link #COMPONENT_ENABLED_STATE_ENABLED},
2527      *                   {@link #COMPONENT_ENABLED_STATE_DISABLED}
2528      *                   and
2529      *                   {@link #COMPONENT_ENABLED_STATE_DEFAULT}
2530      *                 The last one removes the setting, thereby restoring the component's state to
2531      *                 whatever was set in it's manifest (or enabled, by default).
2532      * @param flags Optional behavior flags: {@link #DONT_KILL_APP} or 0.
2533      */
setComponentEnabledSetting(ComponentName componentName, int newState, int flags)2534     public abstract void setComponentEnabledSetting(ComponentName componentName,
2535             int newState, int flags);
2536 
2537 
2538     /**
2539      * Return the the enabled setting for a package component (activity,
2540      * receiver, service, provider).  This returns the last value set by
2541      * {@link #setComponentEnabledSetting(ComponentName, int, int)}; in most
2542      * cases this value will be {@link #COMPONENT_ENABLED_STATE_DEFAULT} since
2543      * the value originally specified in the manifest has not been modified.
2544      *
2545      * @param componentName The component to retrieve.
2546      * @return Returns the current enabled state for the component.  May
2547      * be one of {@link #COMPONENT_ENABLED_STATE_ENABLED},
2548      * {@link #COMPONENT_ENABLED_STATE_DISABLED}, or
2549      * {@link #COMPONENT_ENABLED_STATE_DEFAULT}.  The last one means the
2550      * component's enabled state is based on the original information in
2551      * the manifest as found in {@link ComponentInfo}.
2552      */
getComponentEnabledSetting(ComponentName componentName)2553     public abstract int getComponentEnabledSetting(ComponentName componentName);
2554 
2555     /**
2556      * Set the enabled setting for an application
2557      * This setting will override any enabled state which may have been set by the application in
2558      * its manifest.  It also overrides the enabled state set in the manifest for any of the
2559      * application's components.  It does not override any enabled state set by
2560      * {@link #setComponentEnabledSetting} for any of the application's components.
2561      *
2562      * @param packageName The package name of the application to enable
2563      * @param newState The new enabled state for the component.  The legal values for this state
2564      *                 are:
2565      *                   {@link #COMPONENT_ENABLED_STATE_ENABLED},
2566      *                   {@link #COMPONENT_ENABLED_STATE_DISABLED}
2567      *                   and
2568      *                   {@link #COMPONENT_ENABLED_STATE_DEFAULT}
2569      *                 The last one removes the setting, thereby restoring the applications's state to
2570      *                 whatever was set in its manifest (or enabled, by default).
2571      * @param flags Optional behavior flags: {@link #DONT_KILL_APP} or 0.
2572      */
setApplicationEnabledSetting(String packageName, int newState, int flags)2573     public abstract void setApplicationEnabledSetting(String packageName,
2574             int newState, int flags);
2575 
2576     /**
2577      * Return the the enabled setting for an application.  This returns
2578      * the last value set by
2579      * {@link #setApplicationEnabledSetting(String, int, int)}; in most
2580      * cases this value will be {@link #COMPONENT_ENABLED_STATE_DEFAULT} since
2581      * the value originally specified in the manifest has not been modified.
2582      *
2583      * @param packageName The component to retrieve.
2584      * @return Returns the current enabled state for the component.  May
2585      * be one of {@link #COMPONENT_ENABLED_STATE_ENABLED},
2586      * {@link #COMPONENT_ENABLED_STATE_DISABLED}, or
2587      * {@link #COMPONENT_ENABLED_STATE_DEFAULT}.  The last one means the
2588      * application's enabled state is based on the original information in
2589      * the manifest as found in {@link ComponentInfo}.
2590      * @throws IllegalArgumentException if the named package does not exist.
2591      */
getApplicationEnabledSetting(String packageName)2592     public abstract int getApplicationEnabledSetting(String packageName);
2593 
2594     /**
2595      * Return whether the device has been booted into safe mode.
2596      */
isSafeMode()2597     public abstract boolean isSafeMode();
2598 
2599     /**
2600      * Attempts to move package resources from internal to external media or vice versa.
2601      * Since this may take a little while, the result will
2602      * be posted back to the given observer.   This call may fail if the calling context
2603      * lacks the {@link android.Manifest.permission#MOVE_PACKAGE} permission, if the
2604      * named package cannot be found, or if the named package is a "system package".
2605      *
2606      * @param packageName The name of the package to delete
2607      * @param observer An observer callback to get notified when the package move is
2608      * complete. {@link android.content.pm.IPackageMoveObserver#packageMoved(boolean)} will be
2609      * called when that happens.  observer may be null to indicate that no callback is desired.
2610      * @param flags To indicate install location {@link #MOVE_INTERNAL} or
2611      * {@link #MOVE_EXTERNAL_MEDIA}
2612      *
2613      * @hide
2614      */
movePackage( String packageName, IPackageMoveObserver observer, int flags)2615     public abstract void movePackage(
2616             String packageName, IPackageMoveObserver observer, int flags);
2617 
2618     /**
2619      * Creates a user with the specified name and options.
2620      *
2621      * @param name the user's name
2622      * @param flags flags that identify the type of user and other properties.
2623      * @see UserInfo
2624      *
2625      * @return the UserInfo object for the created user, or null if the user could not be created.
2626      * @hide
2627      */
createUser(String name, int flags)2628     public abstract UserInfo createUser(String name, int flags);
2629 
2630     /**
2631      * @return the list of users that were created
2632      * @hide
2633      */
getUsers()2634     public abstract List<UserInfo> getUsers();
2635 
2636     /**
2637      * @param id the ID of the user, where 0 is the primary user.
2638      * @hide
2639      */
removeUser(int id)2640     public abstract boolean removeUser(int id);
2641 
2642     /**
2643      * Updates the user's name.
2644      *
2645      * @param id the user's id
2646      * @param name the new name for the user
2647      * @hide
2648      */
updateUserName(int id, String name)2649     public abstract void updateUserName(int id, String name);
2650 
2651     /**
2652      * Changes the user's properties specified by the flags.
2653      *
2654      * @param id the user's id
2655      * @param flags the new flags for the user
2656      * @hide
2657      */
updateUserFlags(int id, int flags)2658     public abstract void updateUserFlags(int id, int flags);
2659 
2660     /**
2661      * Returns the details for the user specified by userId.
2662      * @param userId the user id of the user
2663      * @return UserInfo for the specified user, or null if no such user exists.
2664      * @hide
2665      */
getUser(int userId)2666     public abstract UserInfo getUser(int userId);
2667 
2668     /**
2669      * Returns the device identity that verifiers can use to associate their scheme to a particular
2670      * device. This should not be used by anything other than a package verifier.
2671      *
2672      * @return identity that uniquely identifies current device
2673      * @hide
2674      */
getVerifierDeviceIdentity()2675     public abstract VerifierDeviceIdentity getVerifierDeviceIdentity();
2676 
2677     /**
2678      * Returns the data directory for a particular user and package, given the uid of the package.
2679      * @param uid uid of the package, including the userId and appId
2680      * @param packageName name of the package
2681      * @return the user-specific data directory for the package
2682      * @hide
2683      */
getDataDirForUser(int userId, String packageName)2684     public static String getDataDirForUser(int userId, String packageName) {
2685         // TODO: This should be shared with Installer's knowledge of user directory
2686         return Environment.getDataDirectory().toString() + "/user/" + userId
2687                 + "/" + packageName;
2688     }
2689 }
2690