2 * Copyright (C) 2006 The Android Open Source Project
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
17 package com.android.server.pm;
19 import static android.Manifest.permission.GRANT_REVOKE_PERMISSIONS;
20 import static android.Manifest.permission.READ_EXTERNAL_STORAGE;
21 import static android.Manifest.permission.WRITE_EXTERNAL_STORAGE;
22 import static android.Manifest.permission.WRITE_MEDIA_STORAGE;
23 import static android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_DEFAULT;
24 import static android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_DISABLED;
25 import static android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED;
26 import static android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_DISABLED_USER;
27 import static android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_ENABLED;
28 import static android.content.pm.PackageManager.FLAG_PERMISSION_GRANTED_BY_DEFAULT;
29 import static android.content.pm.PackageManager.FLAG_PERMISSION_POLICY_FIXED;
30 import static android.content.pm.PackageManager.FLAG_PERMISSION_REVOKE_ON_UPGRADE;
31 import static android.content.pm.PackageManager.FLAG_PERMISSION_SYSTEM_FIXED;
32 import static android.content.pm.PackageManager.FLAG_PERMISSION_USER_FIXED;
33 import static android.content.pm.PackageManager.FLAG_PERMISSION_USER_SET;
34 import static android.content.pm.PackageManager.INSTALL_EXTERNAL;
35 import static android.content.pm.PackageManager.INSTALL_FAILED_ALREADY_EXISTS;
36 import static android.content.pm.PackageManager.INSTALL_FAILED_CONFLICTING_PROVIDER;
37 import static android.content.pm.PackageManager.INSTALL_FAILED_DEXOPT;
38 import static android.content.pm.PackageManager.INSTALL_FAILED_DUPLICATE_PACKAGE;
39 import static android.content.pm.PackageManager.INSTALL_FAILED_DUPLICATE_PERMISSION;
40 import static android.content.pm.PackageManager.INSTALL_FAILED_INSUFFICIENT_STORAGE;
41 import static android.content.pm.PackageManager.INSTALL_FAILED_INTERNAL_ERROR;
42 import static android.content.pm.PackageManager.INSTALL_FAILED_INVALID_APK;
43 import static android.content.pm.PackageManager.INSTALL_FAILED_INVALID_INSTALL_LOCATION;
44 import static android.content.pm.PackageManager.INSTALL_FAILED_MISSING_SHARED_LIBRARY;
45 import static android.content.pm.PackageManager.INSTALL_FAILED_PACKAGE_CHANGED;
46 import static android.content.pm.PackageManager.INSTALL_FAILED_REPLACE_COULDNT_DELETE;
47 import static android.content.pm.PackageManager.INSTALL_FAILED_SHARED_USER_INCOMPATIBLE;
48 import static android.content.pm.PackageManager.INSTALL_FAILED_TEST_ONLY;
49 import static android.content.pm.PackageManager.INSTALL_FAILED_UID_CHANGED;
50 import static android.content.pm.PackageManager.INSTALL_FAILED_UPDATE_INCOMPATIBLE;
51 import static android.content.pm.PackageManager.INSTALL_FAILED_USER_RESTRICTED;
52 import static android.content.pm.PackageManager.INSTALL_FAILED_VERSION_DOWNGRADE;
53 import static android.content.pm.PackageManager.INSTALL_FORWARD_LOCK;
54 import static android.content.pm.PackageManager.INSTALL_INTERNAL;
55 import static android.content.pm.PackageManager.INSTALL_PARSE_FAILED_INCONSISTENT_CERTIFICATES;
56 import static android.content.pm.PackageManager.INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_ALWAYS;
57 import static android.content.pm.PackageManager.INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_ASK;
58 import static android.content.pm.PackageManager.INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_NEVER;
59 import static android.content.pm.PackageManager.INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_UNDEFINED;
60 import static android.content.pm.PackageManager.MATCH_ALL;
61 import static android.content.pm.PackageManager.MOVE_FAILED_DOESNT_EXIST;
62 import static android.content.pm.PackageManager.MOVE_FAILED_INTERNAL_ERROR;
63 import static android.content.pm.PackageManager.MOVE_FAILED_OPERATION_PENDING;
64 import static android.content.pm.PackageManager.MOVE_FAILED_SYSTEM_PACKAGE;
65 import static android.content.pm.PackageManager.PERMISSION_GRANTED;
66 import static android.content.pm.PackageParser.isApkFile;
67 import static android.os.Process.PACKAGE_INFO_GID;
68 import static android.os.Process.SYSTEM_UID;
69 import static android.system.OsConstants.O_CREAT;
70 import static android.system.OsConstants.O_RDWR;
71 import static com.android.internal.app.IntentForwarderActivity.FORWARD_INTENT_TO_MANAGED_PROFILE;
72 import static com.android.internal.app.IntentForwarderActivity.FORWARD_INTENT_TO_USER_OWNER;
73 import static com.android.internal.content.NativeLibraryHelper.LIB64_DIR_NAME;
74 import static com.android.internal.content.NativeLibraryHelper.LIB_DIR_NAME;
75 import static com.android.internal.util.ArrayUtils.appendInt;
76 import static com.android.server.pm.InstructionSets.getAppDexInstructionSets;
77 import static com.android.server.pm.InstructionSets.getDexCodeInstructionSet;
78 import static com.android.server.pm.InstructionSets.getDexCodeInstructionSets;
79 import static com.android.server.pm.InstructionSets.getPreferredInstructionSet;
80 import static com.android.server.pm.InstructionSets.getPrimaryInstructionSet;
81 import static com.android.server.pm.PermissionsState.PERMISSION_OPERATION_FAILURE;
82 import static com.android.server.pm.PermissionsState.PERMISSION_OPERATION_SUCCESS;
83 import static com.android.server.pm.PermissionsState.PERMISSION_OPERATION_SUCCESS_GIDS_CHANGED;
85 import android.Manifest;
86 import android.app.ActivityManager;
87 import android.app.ActivityManagerNative;
88 import android.app.AppGlobals;
89 import android.app.IActivityManager;
90 import android.app.admin.IDevicePolicyManager;
91 import android.app.backup.IBackupManager;
92 import android.app.usage.UsageStats;
93 import android.app.usage.UsageStatsManager;
94 import android.content.BroadcastReceiver;
95 import android.content.ComponentName;
96 import android.content.Context;
97 import android.content.IIntentReceiver;
98 import android.content.Intent;
99 import android.content.IntentFilter;
100 import android.content.IntentSender;
101 import android.content.IntentSender.SendIntentException;
102 import android.content.ServiceConnection;
103 import android.content.pm.ActivityInfo;
104 import android.content.pm.ApplicationInfo;
105 import android.content.pm.FeatureInfo;
106 import android.content.pm.IOnPermissionsChangeListener;
107 import android.content.pm.IPackageDataObserver;
108 import android.content.pm.IPackageDeleteObserver;
109 import android.content.pm.IPackageDeleteObserver2;
110 import android.content.pm.IPackageInstallObserver2;
111 import android.content.pm.IPackageInstaller;
112 import android.content.pm.IPackageManager;
113 import android.content.pm.IPackageMoveObserver;
114 import android.content.pm.IPackageStatsObserver;
115 import android.content.pm.InstrumentationInfo;
116 import android.content.pm.IntentFilterVerificationInfo;
117 import android.content.pm.KeySet;
118 import android.content.pm.ManifestDigest;
119 import android.content.pm.PackageCleanItem;
120 import android.content.pm.PackageInfo;
121 import android.content.pm.PackageInfoLite;
122 import android.content.pm.PackageInstaller;
123 import android.content.pm.PackageManager;
124 import android.content.pm.PackageManager.LegacyPackageDeleteObserver;
125 import android.content.pm.PackageManagerInternal;
126 import android.content.pm.PackageParser;
127 import android.content.pm.PackageParser.ActivityIntentInfo;
128 import android.content.pm.PackageParser.PackageLite;
129 import android.content.pm.PackageParser.PackageParserException;
130 import android.content.pm.PackageStats;
131 import android.content.pm.PackageUserState;
132 import android.content.pm.ParceledListSlice;
133 import android.content.pm.PermissionGroupInfo;
134 import android.content.pm.PermissionInfo;
135 import android.content.pm.ProviderInfo;
136 import android.content.pm.ResolveInfo;
137 import android.content.pm.ServiceInfo;
138 import android.content.pm.Signature;
139 import android.content.pm.UserInfo;
140 import android.content.pm.VerificationParams;
141 import android.content.pm.VerifierDeviceIdentity;
142 import android.content.pm.VerifierInfo;
143 import android.content.res.Resources;
144 import android.hardware.display.DisplayManager;
145 import android.net.Uri;
146 import android.os.Binder;
147 import android.os.Build;
148 import android.os.Bundle;
149 import android.os.Environment;
150 import android.os.Environment.UserEnvironment;
151 import android.os.FileUtils;
152 import android.os.Handler;
153 import android.os.IBinder;
154 import android.os.Looper;
155 import android.os.Message;
156 import android.os.Parcel;
157 import android.os.ParcelFileDescriptor;
158 import android.os.Process;
159 import android.os.RemoteCallbackList;
160 import android.os.RemoteException;
161 import android.os.SELinux;
162 import android.os.ServiceManager;
163 import android.os.SystemClock;
164 import android.os.SystemProperties;
165 import android.os.UserHandle;
166 import android.os.UserManager;
167 import android.os.storage.IMountService;
168 import android.os.storage.StorageEventListener;
169 import android.os.storage.StorageManager;
170 import android.os.storage.VolumeInfo;
171 import android.os.storage.VolumeRecord;
172 import android.security.KeyStore;
173 import android.security.SystemKeyStore;
174 import android.system.ErrnoException;
175 import android.system.Os;
176 import android.system.StructStat;
177 import android.text.TextUtils;
178 import android.text.format.DateUtils;
179 import android.util.ArrayMap;
180 import android.util.ArraySet;
181 import android.util.AtomicFile;
182 import android.util.DisplayMetrics;
183 import android.util.EventLog;
184 import android.util.ExceptionUtils;
185 import android.util.Log;
186 import android.util.LogPrinter;
187 import android.util.MathUtils;
188 import android.util.PrintStreamPrinter;
189 import android.util.Slog;
190 import android.util.SparseArray;
191 import android.util.SparseBooleanArray;
192 import android.util.SparseIntArray;
193 import android.util.Xml;
194 import android.view.Display;
196 import dalvik.system.DexFile;
197 import dalvik.system.VMRuntime;
199 import libcore.io.IoUtils;
200 import libcore.util.EmptyArray;
202 import com.android.internal.R;
203 import com.android.internal.annotations.GuardedBy;
204 import com.android.internal.app.IMediaContainerService;
205 import com.android.internal.app.ResolverActivity;
206 import com.android.internal.content.NativeLibraryHelper;
207 import com.android.internal.content.PackageHelper;
208 import com.android.internal.os.IParcelFileDescriptorFactory;
209 import com.android.internal.os.SomeArgs;
210 import com.android.internal.os.Zygote;
211 import com.android.internal.util.ArrayUtils;
212 import com.android.internal.util.FastPrintWriter;
213 import com.android.internal.util.FastXmlSerializer;
214 import com.android.internal.util.IndentingPrintWriter;
215 import com.android.internal.util.Preconditions;
216 import com.android.server.EventLogTags;
217 import com.android.server.FgThread;
218 import com.android.server.IntentResolver;
219 import com.android.server.LocalServices;
220 import com.android.server.ServiceThread;
221 import com.android.server.SystemConfig;
222 import com.android.server.Watchdog;
223 import com.android.server.pm.PermissionsState.PermissionState;
224 import com.android.server.pm.Settings.DatabaseVersion;
225 import com.android.server.storage.DeviceStorageMonitorInternal;
227 import org.xmlpull.v1.XmlPullParser;
228 import org.xmlpull.v1.XmlPullParserException;
229 import org.xmlpull.v1.XmlSerializer;
231 import java.io.BufferedInputStream;
232 import java.io.BufferedOutputStream;
233 import java.io.BufferedReader;
234 import java.io.ByteArrayInputStream;
235 import java.io.ByteArrayOutputStream;
237 import java.io.FileDescriptor;
238 import java.io.FileNotFoundException;
239 import java.io.FileOutputStream;
240 import java.io.FileReader;
241 import java.io.FilenameFilter;
242 import java.io.IOException;
243 import java.io.InputStream;
244 import java.io.PrintWriter;
245 import java.nio.charset.StandardCharsets;
246 import java.security.NoSuchAlgorithmException;
247 import java.security.PublicKey;
248 import java.security.cert.CertificateEncodingException;
249 import java.security.cert.CertificateException;
250 import java.text.SimpleDateFormat;
251 import java.util.ArrayList;
252 import java.util.Arrays;
253 import java.util.Collection;
254 import java.util.Collections;
255 import java.util.Comparator;
256 import java.util.Date;
257 import java.util.Iterator;
258 import java.util.List;
259 import java.util.Map;
260 import java.util.Objects;
261 import java.util.Set;
262 import java.util.concurrent.CountDownLatch;
263 import java.util.concurrent.TimeUnit;
264 import java.util.concurrent.atomic.AtomicBoolean;
265 import java.util.concurrent.atomic.AtomicInteger;
266 import java.util.concurrent.atomic.AtomicLong;
269 * Keep track of all those .apks everywhere.
271 * This is very central to the platform's security; please run the unit
272 * tests whenever making modifications here:
274 mmm frameworks/base/tests/AndroidTests
275 adb install -r -f out/target/product/passion/data/app/AndroidTests.apk
276 adb shell am instrument -w -e class com.android.unit_tests.PackageManagerTests com.android.unit_tests/android.test.InstrumentationTestRunner
280 public class PackageManagerService extends IPackageManager.Stub {
281 static final String TAG = "PackageManager";
282 static final boolean DEBUG_SETTINGS = false;
283 static final boolean DEBUG_PREFERRED = false;
284 static final boolean DEBUG_UPGRADE = false;
285 static final boolean DEBUG_DOMAIN_VERIFICATION = false;
286 private static final boolean DEBUG_BACKUP = false;
287 private static final boolean DEBUG_INSTALL = false;
288 private static final boolean DEBUG_REMOVE = false;
289 private static final boolean DEBUG_BROADCASTS = false;
290 private static final boolean DEBUG_SHOW_INFO = false;
291 private static final boolean DEBUG_PACKAGE_INFO = false;
292 private static final boolean DEBUG_INTENT_MATCHING = false;
293 private static final boolean DEBUG_PACKAGE_SCANNING = false;
294 private static final boolean DEBUG_VERIFY = false;
295 private static final boolean DEBUG_DEXOPT = false;
296 private static final boolean DEBUG_ABI_SELECTION = false;
298 static final boolean CLEAR_RUNTIME_PERMISSIONS_ON_UPGRADE = Build.IS_DEBUGGABLE;
300 private static final int RADIO_UID = Process.PHONE_UID;
301 private static final int LOG_UID = Process.LOG_UID;
302 private static final int NFC_UID = Process.NFC_UID;
303 private static final int BLUETOOTH_UID = Process.BLUETOOTH_UID;
304 private static final int SHELL_UID = Process.SHELL_UID;
306 // Cap the size of permission trees that 3rd party apps can define
307 private static final int MAX_PERMISSION_TREE_FOOTPRINT = 32768; // characters of text
309 // Suffix used during package installation when copying/moving
310 // package apks to install directory.
311 private static final String INSTALL_PACKAGE_SUFFIX = "-";
313 static final int SCAN_NO_DEX = 1<<1;
314 static final int SCAN_FORCE_DEX = 1<<2;
315 static final int SCAN_UPDATE_SIGNATURE = 1<<3;
316 static final int SCAN_NEW_INSTALL = 1<<4;
317 static final int SCAN_NO_PATHS = 1<<5;
318 static final int SCAN_UPDATE_TIME = 1<<6;
319 static final int SCAN_DEFER_DEX = 1<<7;
320 static final int SCAN_BOOTING = 1<<8;
321 static final int SCAN_TRUSTED_OVERLAY = 1<<9;
322 static final int SCAN_DELETE_DATA_ON_FAILURES = 1<<10;
323 static final int SCAN_REQUIRE_KNOWN = 1<<12;
324 static final int SCAN_MOVE = 1<<13;
325 static final int SCAN_INITIAL = 1<<14;
327 static final int REMOVE_CHATTY = 1<<16;
329 private static final int[] EMPTY_INT_ARRAY = new int[0];
332 * Timeout (in milliseconds) after which the watchdog should declare that
333 * our handler thread is wedged. The usual default for such things is one
334 * minute but we sometimes do very lengthy I/O operations on this thread,
335 * such as installing multi-gigabyte applications, so ours needs to be longer.
337 private static final long WATCHDOG_TIMEOUT = 1000*60*10; // ten minutes
340 * Wall-clock timeout (in milliseconds) after which we *require* that an fstrim
341 * be run on this device. We use the value in the Settings.Global.MANDATORY_FSTRIM_INTERVAL
342 * settings entry if available, otherwise we use the hardcoded default. If it's been
343 * more than this long since the last fstrim, we force one during the boot sequence.
345 * This backstops other fstrim scheduling: if the device is alive at midnight+idle,
346 * one gets run at the next available charging+idle time. This final mandatory
347 * no-fstrim check kicks in only of the other scheduling criteria is never met.
349 private static final long DEFAULT_MANDATORY_FSTRIM_INTERVAL = 3 * DateUtils.DAY_IN_MILLIS;
352 * Whether verification is enabled by default.
354 private static final boolean DEFAULT_VERIFY_ENABLE = true;
357 * The default maximum time to wait for the verification agent to return in
360 private static final long DEFAULT_VERIFICATION_TIMEOUT = 10 * 1000;
363 * The default response for package verification timeout.
365 * This can be either PackageManager.VERIFICATION_ALLOW or
366 * PackageManager.VERIFICATION_REJECT.
368 private static final int DEFAULT_VERIFICATION_RESPONSE = PackageManager.VERIFICATION_ALLOW;
370 static final String DEFAULT_CONTAINER_PACKAGE = "com.android.defcontainer";
372 static final ComponentName DEFAULT_CONTAINER_COMPONENT = new ComponentName(
373 DEFAULT_CONTAINER_PACKAGE,
374 "com.android.defcontainer.DefaultContainerService");
376 private static final String KILL_APP_REASON_GIDS_CHANGED =
377 "permission grant or revoke changed gids";
379 private static final String KILL_APP_REASON_PERMISSIONS_REVOKED =
380 "permissions revoked";
382 private static final String PACKAGE_MIME_TYPE = "application/vnd.android.package-archive";
384 private static final String VENDOR_OVERLAY_DIR = "/vendor/overlay";
386 /** Permission grant: not grant the permission. */
387 private static final int GRANT_DENIED = 1;
389 /** Permission grant: grant the permission as an install permission. */
390 private static final int GRANT_INSTALL = 2;
392 /** Permission grant: grant the permission as an install permission for a legacy app. */
393 private static final int GRANT_INSTALL_LEGACY = 3;
395 /** Permission grant: grant the permission as a runtime one. */
396 private static final int GRANT_RUNTIME = 4;
398 /** Permission grant: grant as runtime a permission that was granted as an install time one. */
399 private static final int GRANT_UPGRADE = 5;
401 /** Canonical intent used to identify what counts as a "web browser" app */
402 private static final Intent sBrowserIntent;
404 sBrowserIntent = new Intent();
405 sBrowserIntent.setAction(Intent.ACTION_VIEW);
406 sBrowserIntent.addCategory(Intent.CATEGORY_BROWSABLE);
407 sBrowserIntent.setData(Uri.parse("http:"));
410 final ServiceThread mHandlerThread;
412 final PackageHandler mHandler;
415 * Messages for {@link #mHandler} that need to wait for system ready before
418 private ArrayList<Message> mPostSystemReadyMessages;
420 final int mSdkVersion = Build.VERSION.SDK_INT;
422 final Context mContext;
423 final boolean mFactoryTest;
424 final boolean mOnlyCore;
425 final boolean mLazyDexOpt;
426 final long mDexOptLRUThresholdInMills;
427 final DisplayMetrics mMetrics;
428 final int mDefParseFlags;
429 final String[] mSeparateProcesses;
430 final boolean mIsUpgrade;
432 // This is where all application persistent data goes.
433 final File mAppDataDir;
435 // This is where all application persistent data goes for secondary users.
436 final File mUserAppDataDir;
438 /** The location for ASEC container files on internal storage. */
439 final String mAsecInternalPath;
441 // Used for privilege escalation. MUST NOT BE CALLED WITH mPackages
442 // LOCK HELD. Can be called with mInstallLock held.
443 @GuardedBy("mInstallLock")
444 final Installer mInstaller;
446 /** Directory where installed third-party apps stored */
447 final File mAppInstallDir;
450 * Directory to which applications installed internally have their
451 * 32 bit native libraries copied.
453 private File mAppLib32InstallDir;
455 // Directory containing the private parts (e.g. code and non-resource assets) of forward-locked
457 final File mDrmAppPrivateInstallDir;
459 // ----------------------------------------------------------------
461 // Lock for state used when installing and doing other long running
462 // operations. Methods that must be called with this lock held have
464 final Object mInstallLock = new Object();
466 // ----------------------------------------------------------------
468 // Keys are String (package name), values are Package. This also serves
469 // as the lock for the global state. Methods that must be called with
470 // this lock held have the prefix "LP".
471 @GuardedBy("mPackages")
472 final ArrayMap<String, PackageParser.Package> mPackages =
473 new ArrayMap<String, PackageParser.Package>();
475 // Tracks available target package names -> overlay package paths.
476 final ArrayMap<String, ArrayMap<String, PackageParser.Package>> mOverlays =
477 new ArrayMap<String, ArrayMap<String, PackageParser.Package>>();
480 * Tracks new system packages [receiving in an OTA] that we expect to
481 * find updated user-installed versions. Keys are package name, values
482 * are package location.
484 final private ArrayMap<String, File> mExpectingBetter = new ArrayMap<>();
486 final Settings mSettings;
487 boolean mRestoredSettings;
489 // System configuration read by SystemConfig.
490 final int[] mGlobalGids;
491 final SparseArray<ArraySet<String>> mSystemPermissions;
492 final ArrayMap<String, FeatureInfo> mAvailableFeatures;
494 // If mac_permissions.xml was found for seinfo labeling.
495 boolean mFoundPolicyFile;
497 // If a recursive restorecon of /data/data/<pkg> is needed.
498 private boolean mShouldRestoreconData = SELinuxMMAC.shouldRestorecon();
500 public static final class SharedLibraryEntry {
501 public final String path;
502 public final String apk;
504 SharedLibraryEntry(String _path, String _apk) {
510 // Currently known shared libraries.
511 final ArrayMap<String, SharedLibraryEntry> mSharedLibraries =
512 new ArrayMap<String, SharedLibraryEntry>();
514 // All available activities, for your resolving pleasure.
515 final ActivityIntentResolver mActivities =
516 new ActivityIntentResolver();
518 // All available receivers, for your resolving pleasure.
519 final ActivityIntentResolver mReceivers =
520 new ActivityIntentResolver();
522 // All available services, for your resolving pleasure.
523 final ServiceIntentResolver mServices = new ServiceIntentResolver();
525 // All available providers, for your resolving pleasure.
526 final ProviderIntentResolver mProviders = new ProviderIntentResolver();
528 // Mapping from provider base names (first directory in content URI codePath)
529 // to the provider information.
530 final ArrayMap<String, PackageParser.Provider> mProvidersByAuthority =
531 new ArrayMap<String, PackageParser.Provider>();
533 // Mapping from instrumentation class names to info about them.
534 final ArrayMap<ComponentName, PackageParser.Instrumentation> mInstrumentation =
535 new ArrayMap<ComponentName, PackageParser.Instrumentation>();
537 // Mapping from permission names to info about them.
538 final ArrayMap<String, PackageParser.PermissionGroup> mPermissionGroups =
539 new ArrayMap<String, PackageParser.PermissionGroup>();
541 // Packages whose data we have transfered into another package, thus
542 // should no longer exist.
543 final ArraySet<String> mTransferedPackages = new ArraySet<String>();
545 // Broadcast actions that are only available to the system.
546 final ArraySet<String> mProtectedBroadcasts = new ArraySet<String>();
548 /** List of packages waiting for verification. */
549 final SparseArray<PackageVerificationState> mPendingVerification
550 = new SparseArray<PackageVerificationState>();
552 /** Set of packages associated with each app op permission. */
553 final ArrayMap<String, ArraySet<String>> mAppOpPermissionPackages = new ArrayMap<>();
555 final PackageInstallerService mInstallerService;
557 private final PackageDexOptimizer mPackageDexOptimizer;
559 private AtomicInteger mNextMoveId = new AtomicInteger();
560 private final MoveCallbacks mMoveCallbacks;
562 private final OnPermissionChangeListeners mOnPermissionChangeListeners;
564 // Cache of users who need badging.
565 SparseBooleanArray mUserNeedsBadging = new SparseBooleanArray();
567 /** Token for keys in mPendingVerification. */
568 private int mPendingVerificationToken = 0;
570 volatile boolean mSystemReady;
571 volatile boolean mSafeMode;
572 volatile boolean mHasSystemUidErrors;
574 ApplicationInfo mAndroidApplication;
575 final ActivityInfo mResolveActivity = new ActivityInfo();
576 final ResolveInfo mResolveInfo = new ResolveInfo();
577 ComponentName mResolveComponentName;
578 PackageParser.Package mPlatformPackage;
579 ComponentName mCustomResolverComponentName;
581 boolean mResolverReplaced = false;
583 private final ComponentName mIntentFilterVerifierComponent;
584 private int mIntentFilterVerificationToken = 0;
586 final SparseArray<IntentFilterVerificationState> mIntentFilterVerificationStates
587 = new SparseArray<IntentFilterVerificationState>();
589 final DefaultPermissionGrantPolicy mDefaultPermissionPolicy =
590 new DefaultPermissionGrantPolicy(this);
592 private static class IFVerificationParams {
593 PackageParser.Package pkg;
598 public IFVerificationParams(PackageParser.Package _pkg, boolean _replacing,
599 int _userId, int _verifierUid) {
601 replacing = _replacing;
603 replacing = _replacing;
604 verifierUid = _verifierUid;
608 private interface IntentFilterVerifier<T extends IntentFilter> {
609 boolean addOneIntentFilterVerification(int verifierId, int userId, int verificationId,
610 T filter, String packageName);
611 void startVerifications(int userId);
612 void receiveVerificationResponse(int verificationId);
615 private class IntentVerifierProxy implements IntentFilterVerifier<ActivityIntentInfo> {
616 private Context mContext;
617 private ComponentName mIntentFilterVerifierComponent;
618 private ArrayList<Integer> mCurrentIntentFilterVerifications = new ArrayList<Integer>();
620 public IntentVerifierProxy(Context context, ComponentName verifierComponent) {
622 mIntentFilterVerifierComponent = verifierComponent;
625 private String getDefaultScheme() {
626 return IntentFilter.SCHEME_HTTPS;
630 public void startVerifications(int userId) {
631 // Launch verifications requests
632 int count = mCurrentIntentFilterVerifications.size();
633 for (int n=0; n<count; n++) {
634 int verificationId = mCurrentIntentFilterVerifications.get(n);
635 final IntentFilterVerificationState ivs =
636 mIntentFilterVerificationStates.get(verificationId);
638 String packageName = ivs.getPackageName();
640 ArrayList<PackageParser.ActivityIntentInfo> filters = ivs.getFilters();
641 final int filterCount = filters.size();
642 ArraySet<String> domainsSet = new ArraySet<>();
643 for (int m=0; m<filterCount; m++) {
644 PackageParser.ActivityIntentInfo filter = filters.get(m);
645 domainsSet.addAll(filter.getHostsList());
647 ArrayList<String> domainsList = new ArrayList<>(domainsSet);
648 synchronized (mPackages) {
649 if (mSettings.createIntentFilterVerificationIfNeededLPw(
650 packageName, domainsList) != null) {
651 scheduleWriteSettingsLocked();
654 sendVerificationRequest(userId, verificationId, ivs);
656 mCurrentIntentFilterVerifications.clear();
659 private void sendVerificationRequest(int userId, int verificationId,
660 IntentFilterVerificationState ivs) {
662 Intent verificationIntent = new Intent(Intent.ACTION_INTENT_FILTER_NEEDS_VERIFICATION);
663 verificationIntent.putExtra(
664 PackageManager.EXTRA_INTENT_FILTER_VERIFICATION_ID,
666 verificationIntent.putExtra(
667 PackageManager.EXTRA_INTENT_FILTER_VERIFICATION_URI_SCHEME,
669 verificationIntent.putExtra(
670 PackageManager.EXTRA_INTENT_FILTER_VERIFICATION_HOSTS,
671 ivs.getHostsString());
672 verificationIntent.putExtra(
673 PackageManager.EXTRA_INTENT_FILTER_VERIFICATION_PACKAGE_NAME,
674 ivs.getPackageName());
675 verificationIntent.setComponent(mIntentFilterVerifierComponent);
676 verificationIntent.addFlags(Intent.FLAG_RECEIVER_FOREGROUND);
678 UserHandle user = new UserHandle(userId);
679 mContext.sendBroadcastAsUser(verificationIntent, user);
680 if (DEBUG_DOMAIN_VERIFICATION) Slog.d(TAG,
681 "Sending IntentFilter verification broadcast");
684 public void receiveVerificationResponse(int verificationId) {
685 IntentFilterVerificationState ivs = mIntentFilterVerificationStates.get(verificationId);
687 final boolean verified = ivs.isVerified();
689 ArrayList<PackageParser.ActivityIntentInfo> filters = ivs.getFilters();
690 final int count = filters.size();
691 if (DEBUG_DOMAIN_VERIFICATION) {
692 Slog.i(TAG, "Received verification response " + verificationId
693 + " for " + count + " filters, verified=" + verified);
695 for (int n=0; n<count; n++) {
696 PackageParser.ActivityIntentInfo filter = filters.get(n);
697 filter.setVerified(verified);
699 if (DEBUG_DOMAIN_VERIFICATION) Slog.d(TAG, "IntentFilter " + filter.toString()
700 + " verified with result:" + verified + " and hosts:"
701 + ivs.getHostsString());
704 mIntentFilterVerificationStates.remove(verificationId);
706 final String packageName = ivs.getPackageName();
707 IntentFilterVerificationInfo ivi = null;
709 synchronized (mPackages) {
710 ivi = mSettings.getIntentFilterVerificationLPr(packageName);
713 Slog.w(TAG, "IntentFilterVerificationInfo not found for verificationId:"
714 + verificationId + " packageName:" + packageName);
717 if (DEBUG_DOMAIN_VERIFICATION) Slog.d(TAG,
718 "Updating IntentFilterVerificationInfo for package " + packageName
719 +" verificationId:" + verificationId);
721 synchronized (mPackages) {
723 ivi.setStatus(INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_ALWAYS);
725 ivi.setStatus(INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_ASK);
727 scheduleWriteSettingsLocked();
729 final int userId = ivs.getUserId();
730 if (userId != UserHandle.USER_ALL) {
731 final int userStatus =
732 mSettings.getIntentFilterVerificationStatusLPr(packageName, userId);
734 int updatedStatus = INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_UNDEFINED;
735 boolean needUpdate = false;
737 // We cannot override the STATUS_ALWAYS / STATUS_NEVER states if they have
738 // already been set by the User thru the Disambiguation dialog
739 switch (userStatus) {
740 case INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_UNDEFINED:
742 updatedStatus = INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_ALWAYS;
744 updatedStatus = INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_ASK;
749 case INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_ASK:
751 updatedStatus = INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_ALWAYS;
761 mSettings.updateIntentFilterVerificationStatusLPw(
762 packageName, updatedStatus, userId);
763 scheduleWritePackageRestrictionsLocked(userId);
770 public boolean addOneIntentFilterVerification(int verifierUid, int userId, int verificationId,
771 ActivityIntentInfo filter, String packageName) {
772 if (!hasValidDomains(filter)) {
775 IntentFilterVerificationState ivs = mIntentFilterVerificationStates.get(verificationId);
777 ivs = createDomainVerificationState(verifierUid, userId, verificationId,
780 if (DEBUG_DOMAIN_VERIFICATION) {
781 Slog.d(TAG, "Adding verification filter for " + packageName + " : " + filter);
783 ivs.addFilter(filter);
787 private IntentFilterVerificationState createDomainVerificationState(int verifierUid,
788 int userId, int verificationId, String packageName) {
789 IntentFilterVerificationState ivs = new IntentFilterVerificationState(
790 verifierUid, userId, packageName);
791 ivs.setPendingState();
792 synchronized (mPackages) {
793 mIntentFilterVerificationStates.append(verificationId, ivs);
794 mCurrentIntentFilterVerifications.add(verificationId);
800 private static boolean hasValidDomains(ActivityIntentInfo filter) {
801 boolean hasHTTPorHTTPS = filter.hasDataScheme(IntentFilter.SCHEME_HTTP) ||
802 filter.hasDataScheme(IntentFilter.SCHEME_HTTPS);
803 if (!hasHTTPorHTTPS) {
809 private IntentFilterVerifier mIntentFilterVerifier;
811 // Set of pending broadcasts for aggregating enable/disable of components.
812 static class PendingPackageBroadcasts {
813 // for each user id, a map of <package name -> components within that package>
814 final SparseArray<ArrayMap<String, ArrayList<String>>> mUidMap;
816 public PendingPackageBroadcasts() {
817 mUidMap = new SparseArray<ArrayMap<String, ArrayList<String>>>(2);
820 public ArrayList<String> get(int userId, String packageName) {
821 ArrayMap<String, ArrayList<String>> packages = getOrAllocate(userId);
822 return packages.get(packageName);
825 public void put(int userId, String packageName, ArrayList<String> components) {
826 ArrayMap<String, ArrayList<String>> packages = getOrAllocate(userId);
827 packages.put(packageName, components);
830 public void remove(int userId, String packageName) {
831 ArrayMap<String, ArrayList<String>> packages = mUidMap.get(userId);
832 if (packages != null) {
833 packages.remove(packageName);
837 public void remove(int userId) {
838 mUidMap.remove(userId);
841 public int userIdCount() {
842 return mUidMap.size();
845 public int userIdAt(int n) {
846 return mUidMap.keyAt(n);
849 public ArrayMap<String, ArrayList<String>> packagesForUserId(int userId) {
850 return mUidMap.get(userId);
854 // total number of pending broadcast entries across all userIds
856 for (int i = 0; i< mUidMap.size(); i++) {
857 num += mUidMap.valueAt(i).size();
862 public void clear() {
866 private ArrayMap<String, ArrayList<String>> getOrAllocate(int userId) {
867 ArrayMap<String, ArrayList<String>> map = mUidMap.get(userId);
869 map = new ArrayMap<String, ArrayList<String>>();
870 mUidMap.put(userId, map);
875 final PendingPackageBroadcasts mPendingBroadcasts = new PendingPackageBroadcasts();
877 // Service Connection to remote media container service to copy
878 // package uri's from external media onto secure containers
879 // or internal storage.
880 private IMediaContainerService mContainerService = null;
882 static final int SEND_PENDING_BROADCAST = 1;
883 static final int MCS_BOUND = 3;
884 static final int END_COPY = 4;
885 static final int INIT_COPY = 5;
886 static final int MCS_UNBIND = 6;
887 static final int START_CLEANING_PACKAGE = 7;
888 static final int FIND_INSTALL_LOC = 8;
889 static final int POST_INSTALL = 9;
890 static final int MCS_RECONNECT = 10;
891 static final int MCS_GIVE_UP = 11;
892 static final int UPDATED_MEDIA_STATUS = 12;
893 static final int WRITE_SETTINGS = 13;
894 static final int WRITE_PACKAGE_RESTRICTIONS = 14;
895 static final int PACKAGE_VERIFIED = 15;
896 static final int CHECK_PENDING_VERIFICATION = 16;
897 static final int START_INTENT_FILTER_VERIFICATIONS = 17;
898 static final int INTENT_FILTER_VERIFIED = 18;
900 static final int WRITE_SETTINGS_DELAY = 10*1000; // 10 seconds
902 // Delay time in millisecs
903 static final int BROADCAST_DELAY = 10 * 1000;
905 static UserManagerService sUserManager;
907 // Stores a list of users whose package restrictions file needs to be updated
908 private ArraySet<Integer> mDirtyUsers = new ArraySet<Integer>();
910 final private DefaultContainerConnection mDefContainerConn =
911 new DefaultContainerConnection();
912 class DefaultContainerConnection implements ServiceConnection {
913 public void onServiceConnected(ComponentName name, IBinder service) {
914 if (DEBUG_SD_INSTALL) Log.i(TAG, "onServiceConnected");
915 IMediaContainerService imcs =
916 IMediaContainerService.Stub.asInterface(service);
917 mHandler.sendMessage(mHandler.obtainMessage(MCS_BOUND, imcs));
920 public void onServiceDisconnected(ComponentName name) {
921 if (DEBUG_SD_INSTALL) Log.i(TAG, "onServiceDisconnected");
925 // Recordkeeping of restore-after-install operations that are currently in flight
926 // between the Package Manager and the Backup Manager
927 class PostInstallData {
928 public InstallArgs args;
929 public PackageInstalledInfo res;
931 PostInstallData(InstallArgs _a, PackageInstalledInfo _r) {
937 final SparseArray<PostInstallData> mRunningInstalls = new SparseArray<PostInstallData>();
938 int mNextInstallToken = 1; // nonzero; will be wrapped back to 1 when ++ overflows
940 // XML tags for backup/restore of various bits of state
941 private static final String TAG_PREFERRED_BACKUP = "pa";
942 private static final String TAG_DEFAULT_APPS = "da";
943 private static final String TAG_INTENT_FILTER_VERIFICATION = "iv";
945 final String mRequiredVerifierPackage;
946 final String mRequiredInstallerPackage;
948 private final PackageUsage mPackageUsage = new PackageUsage();
950 private class PackageUsage {
951 private static final int WRITE_INTERVAL
952 = (DEBUG_DEXOPT) ? 0 : 30*60*1000; // 30m in ms
954 private final Object mFileLock = new Object();
955 private final AtomicLong mLastWritten = new AtomicLong(0);
956 private final AtomicBoolean mBackgroundWriteRunning = new AtomicBoolean(false);
958 private boolean mIsHistoricalPackageUsageAvailable = true;
960 boolean isHistoricalPackageUsageAvailable() {
961 return mIsHistoricalPackageUsageAvailable;
964 void write(boolean force) {
969 if (SystemClock.elapsedRealtime() - mLastWritten.get() < WRITE_INTERVAL
973 if (mBackgroundWriteRunning.compareAndSet(false, true)) {
974 new Thread("PackageUsage_DiskWriter") {
980 mBackgroundWriteRunning.set(false);
987 private void writeInternal() {
988 synchronized (mPackages) {
989 synchronized (mFileLock) {
990 AtomicFile file = getFile();
991 FileOutputStream f = null;
993 f = file.startWrite();
994 BufferedOutputStream out = new BufferedOutputStream(f);
995 FileUtils.setPermissions(file.getBaseFile().getPath(), 0640, SYSTEM_UID, PACKAGE_INFO_GID);
996 StringBuilder sb = new StringBuilder();
997 for (PackageParser.Package pkg : mPackages.values()) {
998 if (pkg.mLastPackageUsageTimeInMills == 0) {
1002 sb.append(pkg.packageName);
1004 sb.append((long)pkg.mLastPackageUsageTimeInMills);
1006 out.write(sb.toString().getBytes(StandardCharsets.US_ASCII));
1009 file.finishWrite(f);
1010 } catch (IOException e) {
1014 Log.e(TAG, "Failed to write package usage times", e);
1018 mLastWritten.set(SystemClock.elapsedRealtime());
1022 synchronized (mFileLock) {
1023 AtomicFile file = getFile();
1024 BufferedInputStream in = null;
1026 in = new BufferedInputStream(file.openRead());
1027 StringBuffer sb = new StringBuffer();
1029 String packageName = readToken(in, sb, ' ');
1030 if (packageName == null) {
1033 String timeInMillisString = readToken(in, sb, '\n');
1034 if (timeInMillisString == null) {
1035 throw new IOException("Failed to find last usage time for package "
1038 PackageParser.Package pkg = mPackages.get(packageName);
1044 timeInMillis = Long.parseLong(timeInMillisString.toString());
1045 } catch (NumberFormatException e) {
1046 throw new IOException("Failed to parse " + timeInMillisString
1047 + " as a long.", e);
1049 pkg.mLastPackageUsageTimeInMills = timeInMillis;
1051 } catch (FileNotFoundException expected) {
1052 mIsHistoricalPackageUsageAvailable = false;
1053 } catch (IOException e) {
1054 Log.w(TAG, "Failed to read package usage times", e);
1056 IoUtils.closeQuietly(in);
1059 mLastWritten.set(SystemClock.elapsedRealtime());
1062 private String readToken(InputStream in, StringBuffer sb, char endOfToken)
1063 throws IOException {
1068 if (sb.length() == 0) {
1071 throw new IOException("Unexpected EOF");
1073 if (ch == endOfToken) {
1074 return sb.toString();
1076 sb.append((char)ch);
1080 private AtomicFile getFile() {
1081 File dataDir = Environment.getDataDirectory();
1082 File systemDir = new File(dataDir, "system");
1083 File fname = new File(systemDir, "package-usage.list");
1084 return new AtomicFile(fname);
1088 class PackageHandler extends Handler {
1089 private boolean mBound = false;
1090 final ArrayList<HandlerParams> mPendingInstalls =
1091 new ArrayList<HandlerParams>();
1093 private boolean connectToService() {
1094 if (DEBUG_SD_INSTALL) Log.i(TAG, "Trying to bind to" +
1095 " DefaultContainerService");
1096 Intent service = new Intent().setComponent(DEFAULT_CONTAINER_COMPONENT);
1097 Process.setThreadPriority(Process.THREAD_PRIORITY_DEFAULT);
1098 if (mContext.bindServiceAsUser(service, mDefContainerConn,
1099 Context.BIND_AUTO_CREATE, UserHandle.OWNER)) {
1100 Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
1104 Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
1108 private void disconnectService() {
1109 mContainerService = null;
1111 Process.setThreadPriority(Process.THREAD_PRIORITY_DEFAULT);
1112 mContext.unbindService(mDefContainerConn);
1113 Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
1116 PackageHandler(Looper looper) {
1120 public void handleMessage(Message msg) {
1122 doHandleMessage(msg);
1124 Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
1128 void doHandleMessage(Message msg) {
1131 HandlerParams params = (HandlerParams) msg.obj;
1132 int idx = mPendingInstalls.size();
1133 if (DEBUG_INSTALL) Slog.i(TAG, "init_copy idx=" + idx + ": " + params);
1134 // If a bind was already initiated we dont really
1135 // need to do anything. The pending install
1136 // will be processed later on.
1138 // If this is the only one pending we might
1139 // have to bind to the service again.
1140 if (!connectToService()) {
1141 Slog.e(TAG, "Failed to bind to media container service");
1142 params.serviceError();
1145 // Once we bind to the service, the first
1146 // pending request will be processed.
1147 mPendingInstalls.add(idx, params);
1150 mPendingInstalls.add(idx, params);
1151 // Already bound to the service. Just make
1152 // sure we trigger off processing the first request.
1154 mHandler.sendEmptyMessage(MCS_BOUND);
1160 if (DEBUG_INSTALL) Slog.i(TAG, "mcs_bound");
1161 if (msg.obj != null) {
1162 mContainerService = (IMediaContainerService) msg.obj;
1164 if (mContainerService == null) {
1166 // Something seriously wrong since we are not bound and we are not
1167 // waiting for connection. Bail out.
1168 Slog.e(TAG, "Cannot bind to media container service");
1169 for (HandlerParams params : mPendingInstalls) {
1170 // Indicate service bind error
1171 params.serviceError();
1173 mPendingInstalls.clear();
1175 Slog.w(TAG, "Waiting to connect to media container service");
1177 } else if (mPendingInstalls.size() > 0) {
1178 HandlerParams params = mPendingInstalls.get(0);
1179 if (params != null) {
1180 if (params.startCopy()) {
1181 // We are done... look for more work or to
1183 if (DEBUG_SD_INSTALL) Log.i(TAG,
1184 "Checking for more work or unbind...");
1185 // Delete pending install
1186 if (mPendingInstalls.size() > 0) {
1187 mPendingInstalls.remove(0);
1189 if (mPendingInstalls.size() == 0) {
1191 if (DEBUG_SD_INSTALL) Log.i(TAG,
1192 "Posting delayed MCS_UNBIND");
1193 removeMessages(MCS_UNBIND);
1194 Message ubmsg = obtainMessage(MCS_UNBIND);
1195 // Unbind after a little delay, to avoid
1196 // continual thrashing.
1197 sendMessageDelayed(ubmsg, 10000);
1200 // There are more pending requests in queue.
1201 // Just post MCS_BOUND message to trigger processing
1202 // of next pending install.
1203 if (DEBUG_SD_INSTALL) Log.i(TAG,
1204 "Posting MCS_BOUND for next work");
1205 mHandler.sendEmptyMessage(MCS_BOUND);
1210 // Should never happen ideally.
1211 Slog.w(TAG, "Empty queue");
1215 case MCS_RECONNECT: {
1216 if (DEBUG_INSTALL) Slog.i(TAG, "mcs_reconnect");
1217 if (mPendingInstalls.size() > 0) {
1219 disconnectService();
1221 if (!connectToService()) {
1222 Slog.e(TAG, "Failed to bind to media container service");
1223 for (HandlerParams params : mPendingInstalls) {
1224 // Indicate service bind error
1225 params.serviceError();
1227 mPendingInstalls.clear();
1233 // If there is no actual work left, then time to unbind.
1234 if (DEBUG_INSTALL) Slog.i(TAG, "mcs_unbind");
1236 if (mPendingInstalls.size() == 0 && mPendingVerification.size() == 0) {
1238 if (DEBUG_INSTALL) Slog.i(TAG, "calling disconnectService()");
1240 disconnectService();
1242 } else if (mPendingInstalls.size() > 0) {
1243 // There are more pending requests in queue.
1244 // Just post MCS_BOUND message to trigger processing
1245 // of next pending install.
1246 mHandler.sendEmptyMessage(MCS_BOUND);
1252 if (DEBUG_INSTALL) Slog.i(TAG, "mcs_giveup too many retries");
1253 mPendingInstalls.remove(0);
1256 case SEND_PENDING_BROADCAST: {
1258 ArrayList<String> components[];
1261 Process.setThreadPriority(Process.THREAD_PRIORITY_DEFAULT);
1262 synchronized (mPackages) {
1263 if (mPendingBroadcasts == null) {
1266 size = mPendingBroadcasts.size();
1268 // Nothing to be done. Just return
1271 packages = new String[size];
1272 components = new ArrayList[size];
1273 uids = new int[size];
1274 int i = 0; // filling out the above arrays
1276 for (int n = 0; n < mPendingBroadcasts.userIdCount(); n++) {
1277 int packageUserId = mPendingBroadcasts.userIdAt(n);
1278 Iterator<Map.Entry<String, ArrayList<String>>> it
1279 = mPendingBroadcasts.packagesForUserId(packageUserId)
1280 .entrySet().iterator();
1281 while (it.hasNext() && i < size) {
1282 Map.Entry<String, ArrayList<String>> ent = it.next();
1283 packages[i] = ent.getKey();
1284 components[i] = ent.getValue();
1285 PackageSetting ps = mSettings.mPackages.get(ent.getKey());
1286 uids[i] = (ps != null)
1287 ? UserHandle.getUid(packageUserId, ps.appId)
1293 mPendingBroadcasts.clear();
1296 for (int i = 0; i < size; i++) {
1297 sendPackageChangedBroadcast(packages[i], true, components[i], uids[i]);
1299 Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
1302 case START_CLEANING_PACKAGE: {
1303 Process.setThreadPriority(Process.THREAD_PRIORITY_DEFAULT);
1304 final String packageName = (String)msg.obj;
1305 final int userId = msg.arg1;
1306 final boolean andCode = msg.arg2 != 0;
1307 synchronized (mPackages) {
1308 if (userId == UserHandle.USER_ALL) {
1309 int[] users = sUserManager.getUserIds();
1310 for (int user : users) {
1311 mSettings.addPackageToCleanLPw(
1312 new PackageCleanItem(user, packageName, andCode));
1315 mSettings.addPackageToCleanLPw(
1316 new PackageCleanItem(userId, packageName, andCode));
1319 Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
1320 startCleaningPackages();
1322 case POST_INSTALL: {
1323 if (DEBUG_INSTALL) Log.v(TAG, "Handling post-install for " + msg.arg1);
1324 PostInstallData data = mRunningInstalls.get(msg.arg1);
1325 mRunningInstalls.delete(msg.arg1);
1326 boolean deleteOld = false;
1329 InstallArgs args = data.args;
1330 PackageInstalledInfo res = data.res;
1332 if (res.returnCode == PackageManager.INSTALL_SUCCEEDED) {
1333 final String packageName = res.pkg.applicationInfo.packageName;
1334 res.removedInfo.sendBroadcast(false, true, false);
1335 Bundle extras = new Bundle(1);
1336 extras.putInt(Intent.EXTRA_UID, res.uid);
1338 // Now that we successfully installed the package, grant runtime
1339 // permissions if requested before broadcasting the install.
1340 if ((args.installFlags
1341 & PackageManager.INSTALL_GRANT_RUNTIME_PERMISSIONS) != 0) {
1342 grantRequestedRuntimePermissions(res.pkg,
1343 args.user.getIdentifier());
1346 // Determine the set of users who are adding this
1347 // package for the first time vs. those who are seeing
1350 int[] updateUsers = new int[0];
1351 if (res.origUsers == null || res.origUsers.length == 0) {
1352 firstUsers = res.newUsers;
1354 firstUsers = new int[0];
1355 for (int i=0; i<res.newUsers.length; i++) {
1356 int user = res.newUsers[i];
1357 boolean isNew = true;
1358 for (int j=0; j<res.origUsers.length; j++) {
1359 if (res.origUsers[j] == user) {
1365 int[] newFirst = new int[firstUsers.length+1];
1366 System.arraycopy(firstUsers, 0, newFirst, 0,
1368 newFirst[firstUsers.length] = user;
1369 firstUsers = newFirst;
1371 int[] newUpdate = new int[updateUsers.length+1];
1372 System.arraycopy(updateUsers, 0, newUpdate, 0,
1373 updateUsers.length);
1374 newUpdate[updateUsers.length] = user;
1375 updateUsers = newUpdate;
1379 sendPackageBroadcast(Intent.ACTION_PACKAGE_ADDED,
1380 packageName, extras, null, null, firstUsers);
1381 final boolean update = res.removedInfo.removedPackage != null;
1383 extras.putBoolean(Intent.EXTRA_REPLACING, true);
1385 sendPackageBroadcast(Intent.ACTION_PACKAGE_ADDED,
1386 packageName, extras, null, null, updateUsers);
1388 sendPackageBroadcast(Intent.ACTION_PACKAGE_REPLACED,
1389 packageName, extras, null, null, updateUsers);
1390 sendPackageBroadcast(Intent.ACTION_MY_PACKAGE_REPLACED,
1391 null, null, packageName, null, updateUsers);
1393 // treat asec-hosted packages like removable media on upgrade
1394 if (res.pkg.isForwardLocked() || isExternal(res.pkg)) {
1395 if (DEBUG_INSTALL) {
1396 Slog.i(TAG, "upgrading pkg " + res.pkg
1397 + " is ASEC-hosted -> AVAILABLE");
1399 int[] uidArray = new int[] { res.pkg.applicationInfo.uid };
1400 ArrayList<String> pkgList = new ArrayList<String>(1);
1401 pkgList.add(packageName);
1402 sendResourcesChangedBroadcast(true, true,
1403 pkgList,uidArray, null);
1406 if (res.removedInfo.args != null) {
1407 // Remove the replaced package's older resources safely now
1411 // If this app is a browser and it's newly-installed for some
1412 // users, clear any default-browser state in those users
1413 if (firstUsers.length > 0) {
1414 // the app's nature doesn't depend on the user, so we can just
1415 // check its browser nature in any user and generalize.
1416 if (packageIsBrowser(packageName, firstUsers[0])) {
1417 synchronized (mPackages) {
1418 for (int userId : firstUsers) {
1419 mSettings.setDefaultBrowserPackageNameLPw(null, userId);
1424 // Log current value of "unknown sources" setting
1425 EventLog.writeEvent(EventLogTags.UNKNOWN_SOURCES_ENABLED,
1426 getUnknownSourcesSettings());
1428 // Force a gc to clear up things
1429 Runtime.getRuntime().gc();
1430 // We delete after a gc for applications on sdcard.
1432 synchronized (mInstallLock) {
1433 res.removedInfo.args.doPostDeleteLI(true);
1436 if (args.observer != null) {
1438 Bundle extras = extrasForInstallResult(res);
1439 args.observer.onPackageInstalled(res.name, res.returnCode,
1440 res.returnMsg, extras);
1441 } catch (RemoteException e) {
1442 Slog.i(TAG, "Observer no longer exists.");
1446 Slog.e(TAG, "Bogus post-install token " + msg.arg1);
1449 case UPDATED_MEDIA_STATUS: {
1450 if (DEBUG_SD_INSTALL) Log.i(TAG, "Got message UPDATED_MEDIA_STATUS");
1451 boolean reportStatus = msg.arg1 == 1;
1452 boolean doGc = msg.arg2 == 1;
1453 if (DEBUG_SD_INSTALL) Log.i(TAG, "reportStatus=" + reportStatus + ", doGc = " + doGc);
1455 // Force a gc to clear up stale containers.
1456 Runtime.getRuntime().gc();
1458 if (msg.obj != null) {
1459 @SuppressWarnings("unchecked")
1460 Set<AsecInstallArgs> args = (Set<AsecInstallArgs>) msg.obj;
1461 if (DEBUG_SD_INSTALL) Log.i(TAG, "Unloading all containers");
1462 // Unload containers
1463 unloadAllContainers(args);
1467 if (DEBUG_SD_INSTALL) Log.i(TAG, "Invoking MountService call back");
1468 PackageHelper.getMountService().finishMediaUpdate();
1469 } catch (RemoteException e) {
1470 Log.e(TAG, "MountService not running?");
1474 case WRITE_SETTINGS: {
1475 Process.setThreadPriority(Process.THREAD_PRIORITY_DEFAULT);
1476 synchronized (mPackages) {
1477 removeMessages(WRITE_SETTINGS);
1478 removeMessages(WRITE_PACKAGE_RESTRICTIONS);
1479 mSettings.writeLPr();
1480 mDirtyUsers.clear();
1482 Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
1484 case WRITE_PACKAGE_RESTRICTIONS: {
1485 Process.setThreadPriority(Process.THREAD_PRIORITY_DEFAULT);
1486 synchronized (mPackages) {
1487 removeMessages(WRITE_PACKAGE_RESTRICTIONS);
1488 for (int userId : mDirtyUsers) {
1489 mSettings.writePackageRestrictionsLPr(userId);
1491 mDirtyUsers.clear();
1493 Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
1495 case CHECK_PENDING_VERIFICATION: {
1496 final int verificationId = msg.arg1;
1497 final PackageVerificationState state = mPendingVerification.get(verificationId);
1499 if ((state != null) && !state.timeoutExtended()) {
1500 final InstallArgs args = state.getInstallArgs();
1501 final Uri originUri = Uri.fromFile(args.origin.resolvedFile);
1503 Slog.i(TAG, "Verification timed out for " + originUri);
1504 mPendingVerification.remove(verificationId);
1506 int ret = PackageManager.INSTALL_FAILED_VERIFICATION_FAILURE;
1508 if (getDefaultVerificationResponse() == PackageManager.VERIFICATION_ALLOW) {
1509 Slog.i(TAG, "Continuing with installation of " + originUri);
1510 state.setVerifierResponse(Binder.getCallingUid(),
1511 PackageManager.VERIFICATION_ALLOW_WITHOUT_SUFFICIENT);
1512 broadcastPackageVerified(verificationId, originUri,
1513 PackageManager.VERIFICATION_ALLOW,
1514 state.getInstallArgs().getUser());
1516 ret = args.copyApk(mContainerService, true);
1517 } catch (RemoteException e) {
1518 Slog.e(TAG, "Could not contact the ContainerService");
1521 broadcastPackageVerified(verificationId, originUri,
1522 PackageManager.VERIFICATION_REJECT,
1523 state.getInstallArgs().getUser());
1526 processPendingInstall(args, ret);
1527 mHandler.sendEmptyMessage(MCS_UNBIND);
1531 case PACKAGE_VERIFIED: {
1532 final int verificationId = msg.arg1;
1534 final PackageVerificationState state = mPendingVerification.get(verificationId);
1535 if (state == null) {
1536 Slog.w(TAG, "Invalid verification token " + verificationId + " received");
1540 final PackageVerificationResponse response = (PackageVerificationResponse) msg.obj;
1542 state.setVerifierResponse(response.callerUid, response.code);
1544 if (state.isVerificationComplete()) {
1545 mPendingVerification.remove(verificationId);
1547 final InstallArgs args = state.getInstallArgs();
1548 final Uri originUri = Uri.fromFile(args.origin.resolvedFile);
1551 if (state.isInstallAllowed()) {
1552 ret = PackageManager.INSTALL_FAILED_INTERNAL_ERROR;
1553 broadcastPackageVerified(verificationId, originUri,
1554 response.code, state.getInstallArgs().getUser());
1556 ret = args.copyApk(mContainerService, true);
1557 } catch (RemoteException e) {
1558 Slog.e(TAG, "Could not contact the ContainerService");
1561 ret = PackageManager.INSTALL_FAILED_VERIFICATION_FAILURE;
1564 processPendingInstall(args, ret);
1566 mHandler.sendEmptyMessage(MCS_UNBIND);
1571 case START_INTENT_FILTER_VERIFICATIONS: {
1572 IFVerificationParams params = (IFVerificationParams) msg.obj;
1573 verifyIntentFiltersIfNeeded(params.userId, params.verifierUid,
1574 params.replacing, params.pkg);
1577 case INTENT_FILTER_VERIFIED: {
1578 final int verificationId = msg.arg1;
1580 final IntentFilterVerificationState state = mIntentFilterVerificationStates.get(
1582 if (state == null) {
1583 Slog.w(TAG, "Invalid IntentFilter verification token "
1584 + verificationId + " received");
1588 final int userId = state.getUserId();
1590 if (DEBUG_DOMAIN_VERIFICATION) Slog.d(TAG,
1591 "Processing IntentFilter verification with token:"
1592 + verificationId + " and userId:" + userId);
1594 final IntentFilterVerificationResponse response =
1595 (IntentFilterVerificationResponse) msg.obj;
1597 state.setVerifierResponse(response.callerUid, response.code);
1599 if (DEBUG_DOMAIN_VERIFICATION) Slog.d(TAG,
1600 "IntentFilter verification with token:" + verificationId
1601 + " and userId:" + userId
1602 + " is settings verifier response with response code:"
1605 if (response.code == PackageManager.INTENT_FILTER_VERIFICATION_FAILURE) {
1606 if (DEBUG_DOMAIN_VERIFICATION) Slog.d(TAG, "Domains failing verification: "
1607 + response.getFailedDomainsString());
1610 if (state.isVerificationComplete()) {
1611 mIntentFilterVerifier.receiveVerificationResponse(verificationId);
1613 if (DEBUG_DOMAIN_VERIFICATION) Slog.d(TAG,
1614 "IntentFilter verification with token:" + verificationId
1615 + " was not said to be complete");
1624 private StorageEventListener mStorageListener = new StorageEventListener() {
1626 public void onVolumeStateChanged(VolumeInfo vol, int oldState, int newState) {
1627 if (vol.type == VolumeInfo.TYPE_PRIVATE) {
1628 if (vol.state == VolumeInfo.STATE_MOUNTED) {
1629 final String volumeUuid = vol.getFsUuid();
1631 // Clean up any users or apps that were removed or recreated
1632 // while this volume was missing
1633 reconcileUsers(volumeUuid);
1634 reconcileApps(volumeUuid);
1636 // Clean up any install sessions that expired or were
1637 // cancelled while this volume was missing
1638 mInstallerService.onPrivateVolumeMounted(volumeUuid);
1640 loadPrivatePackages(vol);
1642 } else if (vol.state == VolumeInfo.STATE_EJECTING) {
1643 unloadPrivatePackages(vol);
1647 if (vol.type == VolumeInfo.TYPE_PUBLIC && vol.isPrimary()) {
1648 if (vol.state == VolumeInfo.STATE_MOUNTED) {
1649 updateExternalMediaStatus(true, false);
1650 } else if (vol.state == VolumeInfo.STATE_EJECTING) {
1651 updateExternalMediaStatus(false, false);
1657 public void onVolumeForgotten(String fsUuid) {
1658 // Remove any apps installed on the forgotten volume
1659 synchronized (mPackages) {
1660 final List<PackageSetting> packages = mSettings.getVolumePackagesLPr(fsUuid);
1661 for (PackageSetting ps : packages) {
1662 Slog.d(TAG, "Destroying " + ps.name + " because volume was forgotten");
1663 deletePackage(ps.name, new LegacyPackageDeleteObserver(null).getBinder(),
1664 UserHandle.USER_OWNER, PackageManager.DELETE_ALL_USERS);
1667 mSettings.writeLPr();
1672 private void grantRequestedRuntimePermissions(PackageParser.Package pkg, int userId) {
1673 if (userId >= UserHandle.USER_OWNER) {
1674 grantRequestedRuntimePermissionsForUser(pkg, userId);
1675 } else if (userId == UserHandle.USER_ALL) {
1676 for (int someUserId : UserManagerService.getInstance().getUserIds()) {
1677 grantRequestedRuntimePermissionsForUser(pkg, someUserId);
1681 // We could have touched GID membership, so flush out packages.list
1682 synchronized (mPackages) {
1683 mSettings.writePackageListLPr();
1687 private void grantRequestedRuntimePermissionsForUser(PackageParser.Package pkg, int userId) {
1688 SettingBase sb = (SettingBase) pkg.mExtras;
1693 PermissionsState permissionsState = sb.getPermissionsState();
1695 for (String permission : pkg.requestedPermissions) {
1696 BasePermission bp = mSettings.mPermissions.get(permission);
1697 if (bp != null && bp.isRuntime()) {
1698 permissionsState.grantRuntimePermission(bp, userId);
1703 Bundle extrasForInstallResult(PackageInstalledInfo res) {
1704 Bundle extras = null;
1705 switch (res.returnCode) {
1706 case PackageManager.INSTALL_FAILED_DUPLICATE_PERMISSION: {
1707 extras = new Bundle();
1708 extras.putString(PackageManager.EXTRA_FAILURE_EXISTING_PERMISSION,
1709 res.origPermission);
1710 extras.putString(PackageManager.EXTRA_FAILURE_EXISTING_PACKAGE,
1714 case PackageManager.INSTALL_SUCCEEDED: {
1715 extras = new Bundle();
1716 extras.putBoolean(Intent.EXTRA_REPLACING,
1717 res.removedInfo != null && res.removedInfo.removedPackage != null);
1724 void scheduleWriteSettingsLocked() {
1725 if (!mHandler.hasMessages(WRITE_SETTINGS)) {
1726 mHandler.sendEmptyMessageDelayed(WRITE_SETTINGS, WRITE_SETTINGS_DELAY);
1730 void scheduleWritePackageRestrictionsLocked(int userId) {
1731 if (!sUserManager.exists(userId)) return;
1732 mDirtyUsers.add(userId);
1733 if (!mHandler.hasMessages(WRITE_PACKAGE_RESTRICTIONS)) {
1734 mHandler.sendEmptyMessageDelayed(WRITE_PACKAGE_RESTRICTIONS, WRITE_SETTINGS_DELAY);
1738 public static PackageManagerService main(Context context, Installer installer,
1739 boolean factoryTest, boolean onlyCore) {
1740 PackageManagerService m = new PackageManagerService(context, installer,
1741 factoryTest, onlyCore);
1742 ServiceManager.addService("package", m);
1746 static String[] splitString(String str, char sep) {
1749 while ((i=str.indexOf(sep, i)) >= 0) {
1754 String[] res = new String[count];
1758 while ((i=str.indexOf(sep, i)) >= 0) {
1759 res[count] = str.substring(lastI, i);
1764 res[count] = str.substring(lastI, str.length());
1768 private static void getDefaultDisplayMetrics(Context context, DisplayMetrics metrics) {
1769 DisplayManager displayManager = (DisplayManager) context.getSystemService(
1770 Context.DISPLAY_SERVICE);
1771 displayManager.getDisplay(Display.DEFAULT_DISPLAY).getMetrics(metrics);
1774 public PackageManagerService(Context context, Installer installer,
1775 boolean factoryTest, boolean onlyCore) {
1776 EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_PMS_START,
1777 SystemClock.uptimeMillis());
1779 if (mSdkVersion <= 0) {
1780 Slog.w(TAG, "**** ro.build.version.sdk not set!");
1784 mFactoryTest = factoryTest;
1785 mOnlyCore = onlyCore;
1786 mLazyDexOpt = "eng".equals(SystemProperties.get("ro.build.type"));
1787 mMetrics = new DisplayMetrics();
1788 mSettings = new Settings(mPackages);
1789 mSettings.addSharedUserLPw("android.uid.system", Process.SYSTEM_UID,
1790 ApplicationInfo.FLAG_SYSTEM, ApplicationInfo.PRIVATE_FLAG_PRIVILEGED);
1791 mSettings.addSharedUserLPw("android.uid.phone", RADIO_UID,
1792 ApplicationInfo.FLAG_SYSTEM, ApplicationInfo.PRIVATE_FLAG_PRIVILEGED);
1793 mSettings.addSharedUserLPw("android.uid.log", LOG_UID,
1794 ApplicationInfo.FLAG_SYSTEM, ApplicationInfo.PRIVATE_FLAG_PRIVILEGED);
1795 mSettings.addSharedUserLPw("android.uid.nfc", NFC_UID,
1796 ApplicationInfo.FLAG_SYSTEM, ApplicationInfo.PRIVATE_FLAG_PRIVILEGED);
1797 mSettings.addSharedUserLPw("android.uid.bluetooth", BLUETOOTH_UID,
1798 ApplicationInfo.FLAG_SYSTEM, ApplicationInfo.PRIVATE_FLAG_PRIVILEGED);
1799 mSettings.addSharedUserLPw("android.uid.shell", SHELL_UID,
1800 ApplicationInfo.FLAG_SYSTEM, ApplicationInfo.PRIVATE_FLAG_PRIVILEGED);
1802 // TODO: add a property to control this?
1803 long dexOptLRUThresholdInMinutes;
1805 dexOptLRUThresholdInMinutes = 30; // only last 30 minutes of apps for eng builds.
1807 dexOptLRUThresholdInMinutes = 7 * 24 * 60; // apps used in the 7 days for users.
1809 mDexOptLRUThresholdInMills = dexOptLRUThresholdInMinutes * 60 * 1000;
1811 String separateProcesses = SystemProperties.get("debug.separate_processes");
1812 if (separateProcesses != null && separateProcesses.length() > 0) {
1813 if ("*".equals(separateProcesses)) {
1814 mDefParseFlags = PackageParser.PARSE_IGNORE_PROCESSES;
1815 mSeparateProcesses = null;
1816 Slog.w(TAG, "Running with debug.separate_processes: * (ALL)");
1819 mSeparateProcesses = separateProcesses.split(",");
1820 Slog.w(TAG, "Running with debug.separate_processes: "
1821 + separateProcesses);
1825 mSeparateProcesses = null;
1828 mInstaller = installer;
1829 mPackageDexOptimizer = new PackageDexOptimizer(this);
1830 mMoveCallbacks = new MoveCallbacks(FgThread.get().getLooper());
1832 mOnPermissionChangeListeners = new OnPermissionChangeListeners(
1833 FgThread.get().getLooper());
1835 getDefaultDisplayMetrics(context, mMetrics);
1837 SystemConfig systemConfig = SystemConfig.getInstance();
1838 mGlobalGids = systemConfig.getGlobalGids();
1839 mSystemPermissions = systemConfig.getSystemPermissions();
1840 mAvailableFeatures = systemConfig.getAvailableFeatures();
1842 synchronized (mInstallLock) {
1844 synchronized (mPackages) {
1845 mHandlerThread = new ServiceThread(TAG,
1846 Process.THREAD_PRIORITY_BACKGROUND, true /*allowIo*/);
1847 mHandlerThread.start();
1848 mHandler = new PackageHandler(mHandlerThread.getLooper());
1849 Watchdog.getInstance().addThread(mHandler, WATCHDOG_TIMEOUT);
1851 File dataDir = Environment.getDataDirectory();
1852 mAppDataDir = new File(dataDir, "data");
1853 mAppInstallDir = new File(dataDir, "app");
1854 mAppLib32InstallDir = new File(dataDir, "app-lib");
1855 mAsecInternalPath = new File(dataDir, "app-asec").getPath();
1856 mUserAppDataDir = new File(dataDir, "user");
1857 mDrmAppPrivateInstallDir = new File(dataDir, "app-private");
1859 sUserManager = new UserManagerService(context, this,
1860 mInstallLock, mPackages);
1862 // Propagate permission configuration in to package manager.
1863 ArrayMap<String, SystemConfig.PermissionEntry> permConfig
1864 = systemConfig.getPermissions();
1865 for (int i=0; i<permConfig.size(); i++) {
1866 SystemConfig.PermissionEntry perm = permConfig.valueAt(i);
1867 BasePermission bp = mSettings.mPermissions.get(perm.name);
1869 bp = new BasePermission(perm.name, "android", BasePermission.TYPE_BUILTIN);
1870 mSettings.mPermissions.put(perm.name, bp);
1872 if (perm.gids != null) {
1873 bp.setGids(perm.gids, perm.perUser);
1877 ArrayMap<String, String> libConfig = systemConfig.getSharedLibraries();
1878 for (int i=0; i<libConfig.size(); i++) {
1879 mSharedLibraries.put(libConfig.keyAt(i),
1880 new SharedLibraryEntry(libConfig.valueAt(i), null));
1883 mFoundPolicyFile = SELinuxMMAC.readInstallPolicy();
1885 mRestoredSettings = mSettings.readLPw(this, sUserManager.getUsers(false),
1886 mSdkVersion, mOnlyCore);
1888 String customResolverActivity = Resources.getSystem().getString(
1889 R.string.config_customResolverActivity);
1890 if (TextUtils.isEmpty(customResolverActivity)) {
1891 customResolverActivity = null;
1893 mCustomResolverComponentName = ComponentName.unflattenFromString(
1894 customResolverActivity);
1897 long startTime = SystemClock.uptimeMillis();
1899 EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_PMS_SYSTEM_SCAN_START,
1902 // Set flag to monitor and not change apk file paths when
1903 // scanning install directories.
1904 final int scanFlags = SCAN_NO_PATHS | SCAN_DEFER_DEX | SCAN_BOOTING | SCAN_INITIAL;
1906 final ArraySet<String> alreadyDexOpted = new ArraySet<String>();
1909 * Add everything in the in the boot class path to the
1910 * list of process files because dexopt will have been run
1911 * if necessary during zygote startup.
1913 final String bootClassPath = System.getenv("BOOTCLASSPATH");
1914 final String systemServerClassPath = System.getenv("SYSTEMSERVERCLASSPATH");
1916 if (bootClassPath != null) {
1917 String[] bootClassPathElements = splitString(bootClassPath, ':');
1918 for (String element : bootClassPathElements) {
1919 alreadyDexOpted.add(element);
1922 Slog.w(TAG, "No BOOTCLASSPATH found!");
1925 if (systemServerClassPath != null) {
1926 String[] systemServerClassPathElements = splitString(systemServerClassPath, ':');
1927 for (String element : systemServerClassPathElements) {
1928 alreadyDexOpted.add(element);
1931 Slog.w(TAG, "No SYSTEMSERVERCLASSPATH found!");
1934 final List<String> allInstructionSets = InstructionSets.getAllInstructionSets();
1935 final String[] dexCodeInstructionSets =
1936 getDexCodeInstructionSets(
1937 allInstructionSets.toArray(new String[allInstructionSets.size()]));
1940 * Ensure all external libraries have had dexopt run on them.
1942 if (mSharedLibraries.size() > 0) {
1943 // NOTE: For now, we're compiling these system "shared libraries"
1944 // (and framework jars) into all available architectures. It's possible
1945 // to compile them only when we come across an app that uses them (there's
1946 // already logic for that in scanPackageLI) but that adds some complexity.
1947 for (String dexCodeInstructionSet : dexCodeInstructionSets) {
1948 for (SharedLibraryEntry libEntry : mSharedLibraries.values()) {
1949 final String lib = libEntry.path;
1955 int dexoptNeeded = DexFile.getDexOptNeeded(lib, null, dexCodeInstructionSet, false);
1956 if (dexoptNeeded != DexFile.NO_DEXOPT_NEEDED) {
1957 alreadyDexOpted.add(lib);
1958 mInstaller.dexopt(lib, Process.SYSTEM_UID, true, dexCodeInstructionSet, dexoptNeeded);
1960 } catch (FileNotFoundException e) {
1961 Slog.w(TAG, "Library not found: " + lib);
1962 } catch (IOException e) {
1963 Slog.w(TAG, "Cannot dexopt " + lib + "; is it an APK or JAR? "
1970 File frameworkDir = new File(Environment.getRootDirectory(), "framework");
1972 // Gross hack for now: we know this file doesn't contain any
1973 // code, so don't dexopt it to avoid the resulting log spew.
1974 alreadyDexOpted.add(frameworkDir.getPath() + "/framework-res.apk");
1976 // Gross hack for now: we know this file is only part of
1977 // the boot class path for art, so don't dexopt it to
1978 // avoid the resulting log spew.
1979 alreadyDexOpted.add(frameworkDir.getPath() + "/core-libart.jar");
1982 * There are a number of commands implemented in Java, which
1983 * we currently need to do the dexopt on so that they can be
1984 * run from a non-root shell.
1986 String[] frameworkFiles = frameworkDir.list();
1987 if (frameworkFiles != null) {
1988 // TODO: We could compile these only for the most preferred ABI. We should
1989 // first double check that the dex files for these commands are not referenced
1990 // by other system apps.
1991 for (String dexCodeInstructionSet : dexCodeInstructionSets) {
1992 for (int i=0; i<frameworkFiles.length; i++) {
1993 File libPath = new File(frameworkDir, frameworkFiles[i]);
1994 String path = libPath.getPath();
1995 // Skip the file if we already did it.
1996 if (alreadyDexOpted.contains(path)) {
1999 // Skip the file if it is not a type we want to dexopt.
2000 if (!path.endsWith(".apk") && !path.endsWith(".jar")) {
2004 int dexoptNeeded = DexFile.getDexOptNeeded(path, null, dexCodeInstructionSet, false);
2005 if (dexoptNeeded != DexFile.NO_DEXOPT_NEEDED) {
2006 mInstaller.dexopt(path, Process.SYSTEM_UID, true, dexCodeInstructionSet, dexoptNeeded);
2008 } catch (FileNotFoundException e) {
2009 Slog.w(TAG, "Jar not found: " + path);
2010 } catch (IOException e) {
2011 Slog.w(TAG, "Exception reading jar: " + path, e);
2017 // Collect vendor overlay packages.
2018 // (Do this before scanning any apps.)
2019 // For security and version matching reason, only consider
2020 // overlay packages if they reside in VENDOR_OVERLAY_DIR.
2021 File vendorOverlayDir = new File(VENDOR_OVERLAY_DIR);
2022 scanDirLI(vendorOverlayDir, PackageParser.PARSE_IS_SYSTEM
2023 | PackageParser.PARSE_IS_SYSTEM_DIR, scanFlags | SCAN_TRUSTED_OVERLAY, 0);
2025 // Find base frameworks (resource packages without code).
2026 scanDirLI(frameworkDir, PackageParser.PARSE_IS_SYSTEM
2027 | PackageParser.PARSE_IS_SYSTEM_DIR
2028 | PackageParser.PARSE_IS_PRIVILEGED,
2029 scanFlags | SCAN_NO_DEX, 0);
2031 // Collected privileged system packages.
2032 final File privilegedAppDir = new File(Environment.getRootDirectory(), "priv-app");
2033 scanDirLI(privilegedAppDir, PackageParser.PARSE_IS_SYSTEM
2034 | PackageParser.PARSE_IS_SYSTEM_DIR
2035 | PackageParser.PARSE_IS_PRIVILEGED, scanFlags, 0);
2037 // Collect ordinary system packages.
2038 final File systemAppDir = new File(Environment.getRootDirectory(), "app");
2039 scanDirLI(systemAppDir, PackageParser.PARSE_IS_SYSTEM
2040 | PackageParser.PARSE_IS_SYSTEM_DIR, scanFlags, 0);
2042 // Collect all vendor packages.
2043 File vendorAppDir = new File("/vendor/app");
2045 vendorAppDir = vendorAppDir.getCanonicalFile();
2046 } catch (IOException e) {
2047 // failed to look up canonical path, continue with original one
2049 scanDirLI(vendorAppDir, PackageParser.PARSE_IS_SYSTEM
2050 | PackageParser.PARSE_IS_SYSTEM_DIR, scanFlags, 0);
2052 // Collect all OEM packages.
2053 final File oemAppDir = new File(Environment.getOemDirectory(), "app");
2054 scanDirLI(oemAppDir, PackageParser.PARSE_IS_SYSTEM
2055 | PackageParser.PARSE_IS_SYSTEM_DIR, scanFlags, 0);
2057 if (DEBUG_UPGRADE) Log.v(TAG, "Running installd update commands");
2058 mInstaller.moveFiles();
2060 // Prune any system packages that no longer exist.
2061 final List<String> possiblyDeletedUpdatedSystemApps = new ArrayList<String>();
2063 Iterator<PackageSetting> psit = mSettings.mPackages.values().iterator();
2064 while (psit.hasNext()) {
2065 PackageSetting ps = psit.next();
2068 * If this is not a system app, it can't be a
2069 * disable system app.
2071 if ((ps.pkgFlags & ApplicationInfo.FLAG_SYSTEM) == 0) {
2076 * If the package is scanned, it's not erased.
2078 final PackageParser.Package scannedPkg = mPackages.get(ps.name);
2079 if (scannedPkg != null) {
2081 * If the system app is both scanned and in the
2082 * disabled packages list, then it must have been
2083 * added via OTA. Remove it from the currently
2084 * scanned package so the previously user-installed
2085 * application can be scanned.
2087 if (mSettings.isDisabledSystemPackageLPr(ps.name)) {
2088 logCriticalInfo(Log.WARN, "Expecting better updated system app for "
2089 + ps.name + "; removing system app. Last known codePath="
2090 + ps.codePathString + ", installStatus=" + ps.installStatus
2091 + ", versionCode=" + ps.versionCode + "; scanned versionCode="
2092 + scannedPkg.mVersionCode);
2093 removePackageLI(ps, true);
2094 mExpectingBetter.put(ps.name, ps.codePath);
2100 if (!mSettings.isDisabledSystemPackageLPr(ps.name)) {
2102 logCriticalInfo(Log.WARN, "System package " + ps.name
2103 + " no longer exists; wiping its data");
2104 removeDataDirsLI(null, ps.name);
2106 final PackageSetting disabledPs = mSettings.getDisabledSystemPkgLPr(ps.name);
2107 if (disabledPs.codePath == null || !disabledPs.codePath.exists()) {
2108 possiblyDeletedUpdatedSystemApps.add(ps.name);
2114 //look for any incomplete package installations
2115 ArrayList<PackageSetting> deletePkgsList = mSettings.getListOfIncompleteInstallPackagesLPr();
2117 for(int i = 0; i < deletePkgsList.size(); i++) {
2119 cleanupInstallFailedPackage(deletePkgsList.get(i));
2122 deleteTempPackageFiles();
2124 // Remove any shared userIDs that have no associated packages
2125 mSettings.pruneSharedUsersLPw();
2128 EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_PMS_DATA_SCAN_START,
2129 SystemClock.uptimeMillis());
2130 scanDirLI(mAppInstallDir, 0, scanFlags | SCAN_REQUIRE_KNOWN, 0);
2132 scanDirLI(mDrmAppPrivateInstallDir, PackageParser.PARSE_FORWARD_LOCK,
2133 scanFlags | SCAN_REQUIRE_KNOWN, 0);
2136 * Remove disable package settings for any updated system
2137 * apps that were removed via an OTA. If they're not a
2138 * previously-updated app, remove them completely.
2139 * Otherwise, just revoke their system-level permissions.
2141 for (String deletedAppName : possiblyDeletedUpdatedSystemApps) {
2142 PackageParser.Package deletedPkg = mPackages.get(deletedAppName);
2143 mSettings.removeDisabledSystemPackageLPw(deletedAppName);
2146 if (deletedPkg == null) {
2147 msg = "Updated system package " + deletedAppName
2148 + " no longer exists; wiping its data";
2149 removeDataDirsLI(null, deletedAppName);
2151 msg = "Updated system app + " + deletedAppName
2152 + " no longer present; removing system privileges for "
2155 deletedPkg.applicationInfo.flags &= ~ApplicationInfo.FLAG_SYSTEM;
2157 PackageSetting deletedPs = mSettings.mPackages.get(deletedAppName);
2158 deletedPs.pkgFlags &= ~ApplicationInfo.FLAG_SYSTEM;
2160 logCriticalInfo(Log.WARN, msg);
2164 * Make sure all system apps that we expected to appear on
2165 * the userdata partition actually showed up. If they never
2166 * appeared, crawl back and revive the system version.
2168 for (int i = 0; i < mExpectingBetter.size(); i++) {
2169 final String packageName = mExpectingBetter.keyAt(i);
2170 if (!mPackages.containsKey(packageName)) {
2171 final File scanFile = mExpectingBetter.valueAt(i);
2173 logCriticalInfo(Log.WARN, "Expected better " + packageName
2174 + " but never showed up; reverting to system");
2176 final int reparseFlags;
2177 if (FileUtils.contains(privilegedAppDir, scanFile)) {
2178 reparseFlags = PackageParser.PARSE_IS_SYSTEM
2179 | PackageParser.PARSE_IS_SYSTEM_DIR
2180 | PackageParser.PARSE_IS_PRIVILEGED;
2181 } else if (FileUtils.contains(systemAppDir, scanFile)) {
2182 reparseFlags = PackageParser.PARSE_IS_SYSTEM
2183 | PackageParser.PARSE_IS_SYSTEM_DIR;
2184 } else if (FileUtils.contains(vendorAppDir, scanFile)) {
2185 reparseFlags = PackageParser.PARSE_IS_SYSTEM
2186 | PackageParser.PARSE_IS_SYSTEM_DIR;
2187 } else if (FileUtils.contains(oemAppDir, scanFile)) {
2188 reparseFlags = PackageParser.PARSE_IS_SYSTEM
2189 | PackageParser.PARSE_IS_SYSTEM_DIR;
2191 Slog.e(TAG, "Ignoring unexpected fallback path " + scanFile);
2195 mSettings.enableSystemPackageLPw(packageName);
2198 scanPackageLI(scanFile, reparseFlags, scanFlags, 0, null);
2199 } catch (PackageManagerException e) {
2200 Slog.e(TAG, "Failed to parse original system package: "
2206 mExpectingBetter.clear();
2208 // Now that we know all of the shared libraries, update all clients to have
2209 // the correct library paths.
2210 updateAllSharedLibrariesLPw();
2212 for (SharedUserSetting setting : mSettings.getAllSharedUsersLPw()) {
2213 // NOTE: We ignore potential failures here during a system scan (like
2214 // the rest of the commands above) because there's precious little we
2215 // can do about it. A settings error is reported, though.
2216 adjustCpuAbisForSharedUserLPw(setting.packages, null /* scanned package */,
2217 false /* force dexopt */, false /* defer dexopt */);
2220 // Now that we know all the packages we are keeping,
2221 // read and update their last usage times.
2222 mPackageUsage.readLP();
2224 EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_PMS_SCAN_END,
2225 SystemClock.uptimeMillis());
2226 Slog.i(TAG, "Time to scan packages: "
2227 + ((SystemClock.uptimeMillis()-startTime)/1000f)
2230 // If the platform SDK has changed since the last time we booted,
2231 // we need to re-grant app permission to catch any new ones that
2232 // appear. This is really a hack, and means that apps can in some
2233 // cases get permissions that the user didn't initially explicitly
2234 // allow... it would be nice to have some better way to handle
2236 final boolean regrantPermissions = mSettings.mInternalSdkPlatform
2238 if (regrantPermissions) Slog.i(TAG, "Platform changed from "
2239 + mSettings.mInternalSdkPlatform + " to " + mSdkVersion
2240 + "; regranting permissions for internal storage");
2241 mSettings.mInternalSdkPlatform = mSdkVersion;
2243 updatePermissionsLPw(null, null, UPDATE_PERMISSIONS_ALL
2244 | (regrantPermissions
2245 ? (UPDATE_PERMISSIONS_REPLACE_PKG|UPDATE_PERMISSIONS_REPLACE_ALL)
2248 // If this is the first boot, and it is a normal boot, then
2249 // we need to initialize the default preferred apps.
2250 if (!mRestoredSettings && !onlyCore) {
2251 mSettings.applyDefaultPreferredAppsLPw(this, UserHandle.USER_OWNER);
2252 applyFactoryDefaultBrowserLPw(UserHandle.USER_OWNER);
2253 primeDomainVerificationsLPw(UserHandle.USER_OWNER);
2256 // If this is first boot after an OTA, and a normal boot, then
2257 // we need to clear code cache directories.
2258 mIsUpgrade = !Build.FINGERPRINT.equals(mSettings.mFingerprint);
2259 if (mIsUpgrade && !onlyCore) {
2260 Slog.i(TAG, "Build fingerprint changed; clearing code caches");
2261 for (int i = 0; i < mSettings.mPackages.size(); i++) {
2262 final PackageSetting ps = mSettings.mPackages.valueAt(i);
2263 deleteCodeCacheDirsLI(ps.volumeUuid, ps.name);
2265 mSettings.mFingerprint = Build.FINGERPRINT;
2268 checkDefaultBrowser();
2270 // All the changes are done during package scanning.
2271 mSettings.updateInternalDatabaseVersion();
2273 // can downgrade to reader
2274 mSettings.writeLPr();
2276 EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_PMS_READY,
2277 SystemClock.uptimeMillis());
2279 mRequiredVerifierPackage = getRequiredVerifierLPr();
2280 mRequiredInstallerPackage = getRequiredInstallerLPr();
2282 mInstallerService = new PackageInstallerService(context, this);
2284 mIntentFilterVerifierComponent = getIntentFilterVerifierComponentNameLPr();
2285 mIntentFilterVerifier = new IntentVerifierProxy(mContext,
2286 mIntentFilterVerifierComponent);
2288 } // synchronized (mPackages)
2289 } // synchronized (mInstallLock)
2291 // Now after opening every single application zip, make sure they
2292 // are all flushed. Not really needed, but keeps things nice and
2294 Runtime.getRuntime().gc();
2296 // Expose private service for system components to use.
2297 LocalServices.addService(PackageManagerInternal.class, new PackageManagerInternalImpl());
2301 public boolean isFirstBoot() {
2302 return !mRestoredSettings;
2306 public boolean isOnlyCoreApps() {
2311 public boolean isUpgrade() {
2315 private String getRequiredVerifierLPr() {
2316 final Intent verification = new Intent(Intent.ACTION_PACKAGE_NEEDS_VERIFICATION);
2317 final List<ResolveInfo> receivers = queryIntentReceivers(verification, PACKAGE_MIME_TYPE,
2318 PackageManager.GET_DISABLED_COMPONENTS, 0 /* TODO: Which userId? */);
2320 String requiredVerifier = null;
2322 final int N = receivers.size();
2323 for (int i = 0; i < N; i++) {
2324 final ResolveInfo info = receivers.get(i);
2326 if (info.activityInfo == null) {
2330 final String packageName = info.activityInfo.packageName;
2332 if (checkPermission(android.Manifest.permission.PACKAGE_VERIFICATION_AGENT,
2333 packageName, UserHandle.USER_OWNER) != PackageManager.PERMISSION_GRANTED) {
2337 if (requiredVerifier != null) {
2338 throw new RuntimeException("There can be only one required verifier");
2341 requiredVerifier = packageName;
2344 return requiredVerifier;
2347 private String getRequiredInstallerLPr() {
2348 Intent installerIntent = new Intent(Intent.ACTION_INSTALL_PACKAGE);
2349 installerIntent.addCategory(Intent.CATEGORY_DEFAULT);
2350 installerIntent.setDataAndType(Uri.fromFile(new File("foo.apk")), PACKAGE_MIME_TYPE);
2352 final List<ResolveInfo> installers = queryIntentActivities(installerIntent,
2353 PACKAGE_MIME_TYPE, 0, 0);
2355 String requiredInstaller = null;
2357 final int N = installers.size();
2358 for (int i = 0; i < N; i++) {
2359 final ResolveInfo info = installers.get(i);
2360 final String packageName = info.activityInfo.packageName;
2362 if (!info.activityInfo.applicationInfo.isSystemApp()) {
2366 if (requiredInstaller != null) {
2367 throw new RuntimeException("There must be one required installer");
2370 requiredInstaller = packageName;
2373 if (requiredInstaller == null) {
2374 throw new RuntimeException("There must be one required installer");
2377 return requiredInstaller;
2380 private ComponentName getIntentFilterVerifierComponentNameLPr() {
2381 final Intent verification = new Intent(Intent.ACTION_INTENT_FILTER_NEEDS_VERIFICATION);
2382 final List<ResolveInfo> receivers = queryIntentReceivers(verification, PACKAGE_MIME_TYPE,
2383 PackageManager.GET_DISABLED_COMPONENTS, 0 /* userId */);
2385 ComponentName verifierComponentName = null;
2387 int priority = -1000;
2388 final int N = receivers.size();
2389 for (int i = 0; i < N; i++) {
2390 final ResolveInfo info = receivers.get(i);
2392 if (info.activityInfo == null) {
2396 final String packageName = info.activityInfo.packageName;
2398 final PackageSetting ps = mSettings.mPackages.get(packageName);
2403 if (checkPermission(android.Manifest.permission.INTENT_FILTER_VERIFICATION_AGENT,
2404 packageName, UserHandle.USER_OWNER) != PackageManager.PERMISSION_GRANTED) {
2408 // Select the IntentFilterVerifier with the highest priority
2409 if (priority < info.priority) {
2410 priority = info.priority;
2411 verifierComponentName = new ComponentName(packageName, info.activityInfo.name);
2412 if (DEBUG_DOMAIN_VERIFICATION) Slog.d(TAG, "Selecting IntentFilterVerifier: "
2413 + verifierComponentName + " with priority: " + info.priority);
2417 return verifierComponentName;
2420 private void primeDomainVerificationsLPw(int userId) {
2421 if (DEBUG_DOMAIN_VERIFICATION) {
2422 Slog.d(TAG, "Priming domain verifications in user " + userId);
2425 SystemConfig systemConfig = SystemConfig.getInstance();
2426 ArraySet<String> packages = systemConfig.getLinkedApps();
2427 ArraySet<String> domains = new ArraySet<String>();
2429 for (String packageName : packages) {
2430 PackageParser.Package pkg = mPackages.get(packageName);
2432 if (!pkg.isSystemApp()) {
2433 Slog.w(TAG, "Non-system app '" + packageName + "' in sysconfig <app-link>");
2438 for (PackageParser.Activity a : pkg.activities) {
2439 for (ActivityIntentInfo filter : a.intents) {
2440 if (hasValidDomains(filter)) {
2441 domains.addAll(filter.getHostsList());
2446 if (domains.size() > 0) {
2447 if (DEBUG_DOMAIN_VERIFICATION) {
2448 Slog.v(TAG, " + " + packageName);
2450 // 'Undefined' in the global IntentFilterVerificationInfo, i.e. the usual
2451 // state w.r.t. the formal app-linkage "no verification attempted" state;
2452 // and then 'always' in the per-user state actually used for intent resolution.
2453 final IntentFilterVerificationInfo ivi;
2454 ivi = mSettings.createIntentFilterVerificationIfNeededLPw(packageName,
2455 new ArrayList<String>(domains));
2456 ivi.setStatus(INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_UNDEFINED);
2457 mSettings.updateIntentFilterVerificationStatusLPw(packageName,
2458 INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_ALWAYS, userId);
2460 Slog.w(TAG, "Sysconfig <app-link> package '" + packageName
2461 + "' does not handle web links");
2464 Slog.w(TAG, "Unknown package '" + packageName + "' in sysconfig <app-link>");
2468 scheduleWritePackageRestrictionsLocked(userId);
2469 scheduleWriteSettingsLocked();
2472 private void applyFactoryDefaultBrowserLPw(int userId) {
2473 // The default browser app's package name is stored in a string resource,
2474 // with a product-specific overlay used for vendor customization.
2475 String browserPkg = mContext.getResources().getString(
2476 com.android.internal.R.string.default_browser);
2477 if (!TextUtils.isEmpty(browserPkg)) {
2478 // non-empty string => required to be a known package
2479 PackageSetting ps = mSettings.mPackages.get(browserPkg);
2481 Slog.e(TAG, "Product default browser app does not exist: " + browserPkg);
2484 mSettings.setDefaultBrowserPackageNameLPw(browserPkg, userId);
2488 // Nothing valid explicitly set? Make the factory-installed browser the explicit
2489 // default. If there's more than one, just leave everything alone.
2490 if (browserPkg == null) {
2491 calculateDefaultBrowserLPw(userId);
2495 private void calculateDefaultBrowserLPw(int userId) {
2496 List<String> allBrowsers = resolveAllBrowserApps(userId);
2497 final String browserPkg = (allBrowsers.size() == 1) ? allBrowsers.get(0) : null;
2498 mSettings.setDefaultBrowserPackageNameLPw(browserPkg, userId);
2501 private List<String> resolveAllBrowserApps(int userId) {
2502 // Resolve the canonical browser intent and check that the handleAllWebDataURI boolean is set
2503 List<ResolveInfo> list = queryIntentActivities(sBrowserIntent, null,
2504 PackageManager.MATCH_ALL, userId);
2506 final int count = list.size();
2507 List<String> result = new ArrayList<String>(count);
2508 for (int i=0; i<count; i++) {
2509 ResolveInfo info = list.get(i);
2510 if (info.activityInfo == null
2511 || !info.handleAllWebDataURI
2512 || (info.activityInfo.applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM) == 0
2513 || result.contains(info.activityInfo.packageName)) {
2516 result.add(info.activityInfo.packageName);
2522 private boolean packageIsBrowser(String packageName, int userId) {
2523 List<ResolveInfo> list = queryIntentActivities(sBrowserIntent, null,
2524 PackageManager.MATCH_ALL, userId);
2525 final int N = list.size();
2526 for (int i = 0; i < N; i++) {
2527 ResolveInfo info = list.get(i);
2528 if (packageName.equals(info.activityInfo.packageName)) {
2535 private void checkDefaultBrowser() {
2536 final int myUserId = UserHandle.myUserId();
2537 final String packageName = getDefaultBrowserPackageName(myUserId);
2538 if (packageName != null) {
2539 PackageInfo info = getPackageInfo(packageName, 0, myUserId);
2541 Slog.w(TAG, "Default browser no longer installed: " + packageName);
2542 synchronized (mPackages) {
2543 applyFactoryDefaultBrowserLPw(myUserId); // leaves ambiguous when > 1
2550 public boolean onTransact(int code, Parcel data, Parcel reply, int flags)
2551 throws RemoteException {
2553 return super.onTransact(code, data, reply, flags);
2554 } catch (RuntimeException e) {
2555 if (!(e instanceof SecurityException) && !(e instanceof IllegalArgumentException)) {
2556 Slog.wtf(TAG, "Package Manager Crash", e);
2562 void cleanupInstallFailedPackage(PackageSetting ps) {
2563 logCriticalInfo(Log.WARN, "Cleaning up incompletely installed app: " + ps.name);
2565 removeDataDirsLI(ps.volumeUuid, ps.name);
2566 if (ps.codePath != null) {
2567 if (ps.codePath.isDirectory()) {
2568 mInstaller.rmPackageDir(ps.codePath.getAbsolutePath());
2570 ps.codePath.delete();
2573 if (ps.resourcePath != null && !ps.resourcePath.equals(ps.codePath)) {
2574 if (ps.resourcePath.isDirectory()) {
2575 FileUtils.deleteContents(ps.resourcePath);
2577 ps.resourcePath.delete();
2579 mSettings.removePackageLPw(ps.name);
2582 static int[] appendInts(int[] cur, int[] add) {
2583 if (add == null) return cur;
2584 if (cur == null) return add;
2585 final int N = add.length;
2586 for (int i=0; i<N; i++) {
2587 cur = appendInt(cur, add[i]);
2592 PackageInfo generatePackageInfo(PackageParser.Package p, int flags, int userId) {
2593 if (!sUserManager.exists(userId)) return null;
2594 final PackageSetting ps = (PackageSetting) p.mExtras;
2599 final PermissionsState permissionsState = ps.getPermissionsState();
2601 final int[] gids = permissionsState.computeGids(userId);
2602 final Set<String> permissions = permissionsState.getPermissions(userId);
2603 final PackageUserState state = ps.readUserState(userId);
2605 return PackageParser.generatePackageInfo(p, gids, flags,
2606 ps.firstInstallTime, ps.lastUpdateTime, permissions, state, userId);
2610 public boolean isPackageFrozen(String packageName) {
2611 synchronized (mPackages) {
2612 final PackageSetting ps = mSettings.mPackages.get(packageName);
2617 Slog.w(TAG, "Package " + packageName + " is missing; assuming frozen");
2622 public boolean isPackageAvailable(String packageName, int userId) {
2623 if (!sUserManager.exists(userId)) return false;
2624 enforceCrossUserPermission(Binder.getCallingUid(), userId, false, false, "is package available");
2625 synchronized (mPackages) {
2626 PackageParser.Package p = mPackages.get(packageName);
2628 final PackageSetting ps = (PackageSetting) p.mExtras;
2630 final PackageUserState state = ps.readUserState(userId);
2631 if (state != null) {
2632 return PackageParser.isAvailable(state);
2641 public PackageInfo getPackageInfo(String packageName, int flags, int userId) {
2642 if (!sUserManager.exists(userId)) return null;
2643 enforceCrossUserPermission(Binder.getCallingUid(), userId, false, false, "get package info");
2645 synchronized (mPackages) {
2646 PackageParser.Package p = mPackages.get(packageName);
2647 if (DEBUG_PACKAGE_INFO)
2648 Log.v(TAG, "getPackageInfo " + packageName + ": " + p);
2650 return generatePackageInfo(p, flags, userId);
2652 if((flags & PackageManager.GET_UNINSTALLED_PACKAGES) != 0) {
2653 return generatePackageInfoFromSettingsLPw(packageName, flags, userId);
2660 public String[] currentToCanonicalPackageNames(String[] names) {
2661 String[] out = new String[names.length];
2663 synchronized (mPackages) {
2664 for (int i=names.length-1; i>=0; i--) {
2665 PackageSetting ps = mSettings.mPackages.get(names[i]);
2666 out[i] = ps != null && ps.realName != null ? ps.realName : names[i];
2673 public String[] canonicalToCurrentPackageNames(String[] names) {
2674 String[] out = new String[names.length];
2676 synchronized (mPackages) {
2677 for (int i=names.length-1; i>=0; i--) {
2678 String cur = mSettings.mRenamedPackages.get(names[i]);
2679 out[i] = cur != null ? cur : names[i];
2686 public int getPackageUid(String packageName, int userId) {
2687 if (!sUserManager.exists(userId)) return -1;
2688 enforceCrossUserPermission(Binder.getCallingUid(), userId, false, false, "get package uid");
2691 synchronized (mPackages) {
2692 PackageParser.Package p = mPackages.get(packageName);
2694 return UserHandle.getUid(userId, p.applicationInfo.uid);
2696 PackageSetting ps = mSettings.mPackages.get(packageName);
2697 if((ps == null) || (ps.pkg == null) || (ps.pkg.applicationInfo == null)) {
2701 return p != null ? UserHandle.getUid(userId, p.applicationInfo.uid) : -1;
2706 public int[] getPackageGids(String packageName, int userId) throws RemoteException {
2707 if (!sUserManager.exists(userId)) {
2711 enforceCrossUserPermission(Binder.getCallingUid(), userId, false, false,
2715 synchronized (mPackages) {
2716 PackageParser.Package p = mPackages.get(packageName);
2717 if (DEBUG_PACKAGE_INFO) {
2718 Log.v(TAG, "getPackageGids" + packageName + ": " + p);
2721 PackageSetting ps = (PackageSetting) p.mExtras;
2722 return ps.getPermissionsState().computeGids(userId);
2730 public int getMountExternalMode(int uid) {
2731 if (Process.isIsolated(uid)) {
2732 return Zygote.MOUNT_EXTERNAL_NONE;
2734 if (checkUidPermission(WRITE_MEDIA_STORAGE, uid) == PERMISSION_GRANTED) {
2735 return Zygote.MOUNT_EXTERNAL_DEFAULT;
2736 } else if (checkUidPermission(WRITE_EXTERNAL_STORAGE, uid) == PERMISSION_GRANTED) {
2737 return Zygote.MOUNT_EXTERNAL_WRITE;
2738 } else if (checkUidPermission(READ_EXTERNAL_STORAGE, uid) == PERMISSION_GRANTED) {
2739 return Zygote.MOUNT_EXTERNAL_READ;
2741 return Zygote.MOUNT_EXTERNAL_DEFAULT;
2746 static PermissionInfo generatePermissionInfo(
2747 BasePermission bp, int flags) {
2748 if (bp.perm != null) {
2749 return PackageParser.generatePermissionInfo(bp.perm, flags);
2751 PermissionInfo pi = new PermissionInfo();
2753 pi.packageName = bp.sourcePackage;
2754 pi.nonLocalizedLabel = bp.name;
2755 pi.protectionLevel = bp.protectionLevel;
2760 public PermissionInfo getPermissionInfo(String name, int flags) {
2762 synchronized (mPackages) {
2763 final BasePermission p = mSettings.mPermissions.get(name);
2765 return generatePermissionInfo(p, flags);
2772 public List<PermissionInfo> queryPermissionsByGroup(String group, int flags) {
2774 synchronized (mPackages) {
2775 ArrayList<PermissionInfo> out = new ArrayList<PermissionInfo>(10);
2776 for (BasePermission p : mSettings.mPermissions.values()) {
2777 if (group == null) {
2778 if (p.perm == null || p.perm.info.group == null) {
2779 out.add(generatePermissionInfo(p, flags));
2782 if (p.perm != null && group.equals(p.perm.info.group)) {
2783 out.add(PackageParser.generatePermissionInfo(p.perm, flags));
2788 if (out.size() > 0) {
2791 return mPermissionGroups.containsKey(group) ? out : null;
2796 public PermissionGroupInfo getPermissionGroupInfo(String name, int flags) {
2798 synchronized (mPackages) {
2799 return PackageParser.generatePermissionGroupInfo(
2800 mPermissionGroups.get(name), flags);
2805 public List<PermissionGroupInfo> getAllPermissionGroups(int flags) {
2807 synchronized (mPackages) {
2808 final int N = mPermissionGroups.size();
2809 ArrayList<PermissionGroupInfo> out
2810 = new ArrayList<PermissionGroupInfo>(N);
2811 for (PackageParser.PermissionGroup pg : mPermissionGroups.values()) {
2812 out.add(PackageParser.generatePermissionGroupInfo(pg, flags));
2818 private ApplicationInfo generateApplicationInfoFromSettingsLPw(String packageName, int flags,
2820 if (!sUserManager.exists(userId)) return null;
2821 PackageSetting ps = mSettings.mPackages.get(packageName);
2823 if (ps.pkg == null) {
2824 PackageInfo pInfo = generatePackageInfoFromSettingsLPw(packageName,
2826 if (pInfo != null) {
2827 return pInfo.applicationInfo;
2831 return PackageParser.generateApplicationInfo(ps.pkg, flags,
2832 ps.readUserState(userId), userId);
2837 private PackageInfo generatePackageInfoFromSettingsLPw(String packageName, int flags,
2839 if (!sUserManager.exists(userId)) return null;
2840 PackageSetting ps = mSettings.mPackages.get(packageName);
2842 PackageParser.Package pkg = ps.pkg;
2844 if ((flags & PackageManager.GET_UNINSTALLED_PACKAGES) == 0) {
2847 // Only data remains, so we aren't worried about code paths
2848 pkg = new PackageParser.Package(packageName);
2849 pkg.applicationInfo.packageName = packageName;
2850 pkg.applicationInfo.flags = ps.pkgFlags | ApplicationInfo.FLAG_IS_DATA_ONLY;
2851 pkg.applicationInfo.privateFlags = ps.pkgPrivateFlags;
2852 pkg.applicationInfo.dataDir = Environment
2853 .getDataUserPackageDirectory(ps.volumeUuid, userId, packageName)
2855 pkg.applicationInfo.primaryCpuAbi = ps.primaryCpuAbiString;
2856 pkg.applicationInfo.secondaryCpuAbi = ps.secondaryCpuAbiString;
2858 return generatePackageInfo(pkg, flags, userId);
2864 public ApplicationInfo getApplicationInfo(String packageName, int flags, int userId) {
2865 if (!sUserManager.exists(userId)) return null;
2866 enforceCrossUserPermission(Binder.getCallingUid(), userId, false, false, "get application info");
2868 synchronized (mPackages) {
2869 PackageParser.Package p = mPackages.get(packageName);
2870 if (DEBUG_PACKAGE_INFO) Log.v(
2871 TAG, "getApplicationInfo " + packageName
2874 PackageSetting ps = mSettings.mPackages.get(packageName);
2875 if (ps == null) return null;
2876 // Note: isEnabledLP() does not apply here - always return info
2877 return PackageParser.generateApplicationInfo(
2878 p, flags, ps.readUserState(userId), userId);
2880 if ("android".equals(packageName)||"system".equals(packageName)) {
2881 return mAndroidApplication;
2883 if ((flags & PackageManager.GET_UNINSTALLED_PACKAGES) != 0) {
2884 return generateApplicationInfoFromSettingsLPw(packageName, flags, userId);
2891 public void freeStorageAndNotify(final String volumeUuid, final long freeStorageSize,
2892 final IPackageDataObserver observer) {
2893 mContext.enforceCallingOrSelfPermission(
2894 android.Manifest.permission.CLEAR_APP_CACHE, null);
2895 // Queue up an async operation since clearing cache may take a little while.
2896 mHandler.post(new Runnable() {
2898 mHandler.removeCallbacks(this);
2900 synchronized (mInstallLock) {
2901 retCode = mInstaller.freeCache(volumeUuid, freeStorageSize);
2903 Slog.w(TAG, "Couldn't clear application caches");
2906 if (observer != null) {
2908 observer.onRemoveCompleted(null, (retCode >= 0));
2909 } catch (RemoteException e) {
2910 Slog.w(TAG, "RemoveException when invoking call back");
2918 public void freeStorage(final String volumeUuid, final long freeStorageSize,
2919 final IntentSender pi) {
2920 mContext.enforceCallingOrSelfPermission(
2921 android.Manifest.permission.CLEAR_APP_CACHE, null);
2922 // Queue up an async operation since clearing cache may take a little while.
2923 mHandler.post(new Runnable() {
2925 mHandler.removeCallbacks(this);
2927 synchronized (mInstallLock) {
2928 retCode = mInstaller.freeCache(volumeUuid, freeStorageSize);
2930 Slog.w(TAG, "Couldn't clear application caches");
2935 // Callback via pending intent
2936 int code = (retCode >= 0) ? 1 : 0;
2937 pi.sendIntent(null, code, null,
2939 } catch (SendIntentException e1) {
2940 Slog.i(TAG, "Failed to send pending intent");
2947 void freeStorage(String volumeUuid, long freeStorageSize) throws IOException {
2948 synchronized (mInstallLock) {
2949 if (mInstaller.freeCache(volumeUuid, freeStorageSize) < 0) {
2950 throw new IOException("Failed to free enough space");
2956 public ActivityInfo getActivityInfo(ComponentName component, int flags, int userId) {
2957 if (!sUserManager.exists(userId)) return null;
2958 enforceCrossUserPermission(Binder.getCallingUid(), userId, false, false, "get activity info");
2959 synchronized (mPackages) {
2960 PackageParser.Activity a = mActivities.mActivities.get(component);
2962 if (DEBUG_PACKAGE_INFO) Log.v(TAG, "getActivityInfo " + component + ": " + a);
2963 if (a != null && mSettings.isEnabledLPr(a.info, flags, userId)) {
2964 PackageSetting ps = mSettings.mPackages.get(component.getPackageName());
2965 if (ps == null) return null;
2966 return PackageParser.generateActivityInfo(a, flags, ps.readUserState(userId),
2969 if (mResolveComponentName.equals(component)) {
2970 return PackageParser.generateActivityInfo(mResolveActivity, flags,
2971 new PackageUserState(), userId);
2978 public boolean activitySupportsIntent(ComponentName component, Intent intent,
2979 String resolvedType) {
2980 synchronized (mPackages) {
2981 PackageParser.Activity a = mActivities.mActivities.get(component);
2985 for (int i=0; i<a.intents.size(); i++) {
2986 if (a.intents.get(i).match(intent.getAction(), resolvedType, intent.getScheme(),
2987 intent.getData(), intent.getCategories(), TAG) >= 0) {
2996 public ActivityInfo getReceiverInfo(ComponentName component, int flags, int userId) {
2997 if (!sUserManager.exists(userId)) return null;
2998 enforceCrossUserPermission(Binder.getCallingUid(), userId, false, false, "get receiver info");
2999 synchronized (mPackages) {
3000 PackageParser.Activity a = mReceivers.mActivities.get(component);
3001 if (DEBUG_PACKAGE_INFO) Log.v(
3002 TAG, "getReceiverInfo " + component + ": " + a);
3003 if (a != null && mSettings.isEnabledLPr(a.info, flags, userId)) {
3004 PackageSetting ps = mSettings.mPackages.get(component.getPackageName());
3005 if (ps == null) return null;
3006 return PackageParser.generateActivityInfo(a, flags, ps.readUserState(userId),
3014 public ServiceInfo getServiceInfo(ComponentName component, int flags, int userId) {
3015 if (!sUserManager.exists(userId)) return null;
3016 enforceCrossUserPermission(Binder.getCallingUid(), userId, false, false, "get service info");
3017 synchronized (mPackages) {
3018 PackageParser.Service s = mServices.mServices.get(component);
3019 if (DEBUG_PACKAGE_INFO) Log.v(
3020 TAG, "getServiceInfo " + component + ": " + s);
3021 if (s != null && mSettings.isEnabledLPr(s.info, flags, userId)) {
3022 PackageSetting ps = mSettings.mPackages.get(component.getPackageName());
3023 if (ps == null) return null;
3024 return PackageParser.generateServiceInfo(s, flags, ps.readUserState(userId),
3032 public ProviderInfo getProviderInfo(ComponentName component, int flags, int userId) {
3033 if (!sUserManager.exists(userId)) return null;
3034 enforceCrossUserPermission(Binder.getCallingUid(), userId, false, false, "get provider info");
3035 synchronized (mPackages) {
3036 PackageParser.Provider p = mProviders.mProviders.get(component);
3037 if (DEBUG_PACKAGE_INFO) Log.v(
3038 TAG, "getProviderInfo " + component + ": " + p);
3039 if (p != null && mSettings.isEnabledLPr(p.info, flags, userId)) {
3040 PackageSetting ps = mSettings.mPackages.get(component.getPackageName());
3041 if (ps == null) return null;
3042 return PackageParser.generateProviderInfo(p, flags, ps.readUserState(userId),
3050 public String[] getSystemSharedLibraryNames() {
3052 synchronized (mPackages) {
3053 libSet = mSharedLibraries.keySet();
3054 int size = libSet.size();
3056 String[] libs = new String[size];
3057 libSet.toArray(libs);
3067 PackageParser.Package findSharedNonSystemLibrary(String libName) {
3068 synchronized (mPackages) {
3069 PackageManagerService.SharedLibraryEntry lib = mSharedLibraries.get(libName);
3070 if (lib != null && lib.apk != null) {
3071 return mPackages.get(lib.apk);
3078 public FeatureInfo[] getSystemAvailableFeatures() {
3079 Collection<FeatureInfo> featSet;
3080 synchronized (mPackages) {
3081 featSet = mAvailableFeatures.values();
3082 int size = featSet.size();
3084 FeatureInfo[] features = new FeatureInfo[size+1];
3085 featSet.toArray(features);
3086 FeatureInfo fi = new FeatureInfo();
3087 fi.reqGlEsVersion = SystemProperties.getInt("ro.opengles.version",
3088 FeatureInfo.GL_ES_VERSION_UNDEFINED);
3089 features[size] = fi;
3097 public boolean hasSystemFeature(String name) {
3098 synchronized (mPackages) {
3099 return mAvailableFeatures.containsKey(name);
3103 private void checkValidCaller(int uid, int userId) {
3104 if (UserHandle.getUserId(uid) == userId || uid == Process.SYSTEM_UID || uid == 0)
3107 throw new SecurityException("Caller uid=" + uid
3108 + " is not privileged to communicate with user=" + userId);
3112 public int checkPermission(String permName, String pkgName, int userId) {
3113 if (!sUserManager.exists(userId)) {
3114 return PackageManager.PERMISSION_DENIED;
3117 synchronized (mPackages) {
3118 final PackageParser.Package p = mPackages.get(pkgName);
3119 if (p != null && p.mExtras != null) {
3120 final PackageSetting ps = (PackageSetting) p.mExtras;
3121 if (ps.getPermissionsState().hasPermission(permName, userId)) {
3122 return PackageManager.PERMISSION_GRANTED;
3127 return PackageManager.PERMISSION_DENIED;
3131 public int checkUidPermission(String permName, int uid) {
3132 final int userId = UserHandle.getUserId(uid);
3134 if (!sUserManager.exists(userId)) {
3135 return PackageManager.PERMISSION_DENIED;
3138 synchronized (mPackages) {
3139 Object obj = mSettings.getUserIdLPr(UserHandle.getAppId(uid));
3141 final SettingBase ps = (SettingBase) obj;
3142 if (ps.getPermissionsState().hasPermission(permName, userId)) {
3143 return PackageManager.PERMISSION_GRANTED;
3146 ArraySet<String> perms = mSystemPermissions.get(uid);
3147 if (perms != null && perms.contains(permName)) {
3148 return PackageManager.PERMISSION_GRANTED;
3153 return PackageManager.PERMISSION_DENIED;
3157 public boolean isPermissionRevokedByPolicy(String permission, String packageName, int userId) {
3158 if (UserHandle.getCallingUserId() != userId) {
3159 mContext.enforceCallingPermission(
3160 android.Manifest.permission.INTERACT_ACROSS_USERS_FULL,
3161 "isPermissionRevokedByPolicy for user " + userId);
3164 if (checkPermission(permission, packageName, userId)
3165 == PackageManager.PERMISSION_GRANTED) {
3169 final long identity = Binder.clearCallingIdentity();
3171 final int flags = getPermissionFlags(permission, packageName, userId);
3172 return (flags & PackageManager.FLAG_PERMISSION_POLICY_FIXED) != 0;
3174 Binder.restoreCallingIdentity(identity);
3179 * Checks if the request is from the system or an app that has INTERACT_ACROSS_USERS
3180 * or INTERACT_ACROSS_USERS_FULL permissions, if the userid is not for the caller.
3181 * @param checkShell TODO(yamasani):
3182 * @param message the message to log on security exception
3184 void enforceCrossUserPermission(int callingUid, int userId, boolean requireFullPermission,
3185 boolean checkShell, String message) {
3187 throw new IllegalArgumentException("Invalid userId " + userId);
3190 enforceShellRestriction(UserManager.DISALLOW_DEBUGGING_FEATURES, callingUid, userId);
3192 if (userId == UserHandle.getUserId(callingUid)) return;
3193 if (callingUid != Process.SYSTEM_UID && callingUid != 0) {
3194 if (requireFullPermission) {
3195 mContext.enforceCallingOrSelfPermission(
3196 android.Manifest.permission.INTERACT_ACROSS_USERS_FULL, message);
3199 mContext.enforceCallingOrSelfPermission(
3200 android.Manifest.permission.INTERACT_ACROSS_USERS_FULL, message);
3201 } catch (SecurityException se) {
3202 mContext.enforceCallingOrSelfPermission(
3203 android.Manifest.permission.INTERACT_ACROSS_USERS, message);
3209 void enforceShellRestriction(String restriction, int callingUid, int userHandle) {
3210 if (callingUid == Process.SHELL_UID) {
3212 && sUserManager.hasUserRestriction(restriction, userHandle)) {
3213 throw new SecurityException("Shell does not have permission to access user "
3215 } else if (userHandle < 0) {
3216 Slog.e(TAG, "Unable to check shell permission for user " + userHandle + "\n\t"
3217 + Debug.getCallers(3));
3222 private BasePermission findPermissionTreeLP(String permName) {
3223 for(BasePermission bp : mSettings.mPermissionTrees.values()) {
3224 if (permName.startsWith(bp.name) &&
3225 permName.length() > bp.name.length() &&
3226 permName.charAt(bp.name.length()) == '.') {
3233 private BasePermission checkPermissionTreeLP(String permName) {
3234 if (permName != null) {
3235 BasePermission bp = findPermissionTreeLP(permName);
3237 if (bp.uid == UserHandle.getAppId(Binder.getCallingUid())) {
3240 throw new SecurityException("Calling uid "
3241 + Binder.getCallingUid()
3242 + " is not allowed to add to permission tree "
3243 + bp.name + " owned by uid " + bp.uid);
3246 throw new SecurityException("No permission tree found for " + permName);
3249 static boolean compareStrings(CharSequence s1, CharSequence s2) {
3256 if (s1.getClass() != s2.getClass()) {
3259 return s1.equals(s2);
3262 static boolean comparePermissionInfos(PermissionInfo pi1, PermissionInfo pi2) {
3263 if (pi1.icon != pi2.icon) return false;
3264 if (pi1.logo != pi2.logo) return false;
3265 if (pi1.protectionLevel != pi2.protectionLevel) return false;
3266 if (!compareStrings(pi1.name, pi2.name)) return false;
3267 if (!compareStrings(pi1.nonLocalizedLabel, pi2.nonLocalizedLabel)) return false;
3268 // We'll take care of setting this one.
3269 if (!compareStrings(pi1.packageName, pi2.packageName)) return false;
3270 // These are not currently stored in settings.
3271 //if (!compareStrings(pi1.group, pi2.group)) return false;
3272 //if (!compareStrings(pi1.nonLocalizedDescription, pi2.nonLocalizedDescription)) return false;
3273 //if (pi1.labelRes != pi2.labelRes) return false;
3274 //if (pi1.descriptionRes != pi2.descriptionRes) return false;
3278 int permissionInfoFootprint(PermissionInfo info) {
3279 int size = info.name.length();
3280 if (info.nonLocalizedLabel != null) size += info.nonLocalizedLabel.length();
3281 if (info.nonLocalizedDescription != null) size += info.nonLocalizedDescription.length();
3285 int calculateCurrentPermissionFootprintLocked(BasePermission tree) {
3287 for (BasePermission perm : mSettings.mPermissions.values()) {
3288 if (perm.uid == tree.uid) {
3289 size += perm.name.length() + permissionInfoFootprint(perm.perm.info);
3295 void enforcePermissionCapLocked(PermissionInfo info, BasePermission tree) {
3296 // We calculate the max size of permissions defined by this uid and throw
3297 // if that plus the size of 'info' would exceed our stated maximum.
3298 if (tree.uid != Process.SYSTEM_UID) {
3299 final int curTreeSize = calculateCurrentPermissionFootprintLocked(tree);
3300 if (curTreeSize + permissionInfoFootprint(info) > MAX_PERMISSION_TREE_FOOTPRINT) {
3301 throw new SecurityException("Permission tree size cap exceeded");
3306 boolean addPermissionLocked(PermissionInfo info, boolean async) {
3307 if (info.labelRes == 0 && info.nonLocalizedLabel == null) {
3308 throw new SecurityException("Label must be specified in permission");
3310 BasePermission tree = checkPermissionTreeLP(info.name);
3311 BasePermission bp = mSettings.mPermissions.get(info.name);
3312 boolean added = bp == null;
3313 boolean changed = true;
3314 int fixedLevel = PermissionInfo.fixProtectionLevel(info.protectionLevel);
3316 enforcePermissionCapLocked(info, tree);
3317 bp = new BasePermission(info.name, tree.sourcePackage,
3318 BasePermission.TYPE_DYNAMIC);
3319 } else if (bp.type != BasePermission.TYPE_DYNAMIC) {
3320 throw new SecurityException(
3321 "Not allowed to modify non-dynamic permission "
3324 if (bp.protectionLevel == fixedLevel
3325 && bp.perm.owner.equals(tree.perm.owner)
3326 && bp.uid == tree.uid
3327 && comparePermissionInfos(bp.perm.info, info)) {
3331 bp.protectionLevel = fixedLevel;
3332 info = new PermissionInfo(info);
3333 info.protectionLevel = fixedLevel;
3334 bp.perm = new PackageParser.Permission(tree.perm.owner, info);
3335 bp.perm.info.packageName = tree.perm.info.packageName;
3338 mSettings.mPermissions.put(info.name, bp);
3342 mSettings.writeLPr();
3344 scheduleWriteSettingsLocked();
3351 public boolean addPermission(PermissionInfo info) {
3352 synchronized (mPackages) {
3353 return addPermissionLocked(info, false);
3358 public boolean addPermissionAsync(PermissionInfo info) {
3359 synchronized (mPackages) {
3360 return addPermissionLocked(info, true);
3365 public void removePermission(String name) {
3366 synchronized (mPackages) {
3367 checkPermissionTreeLP(name);
3368 BasePermission bp = mSettings.mPermissions.get(name);
3370 if (bp.type != BasePermission.TYPE_DYNAMIC) {
3371 throw new SecurityException(
3372 "Not allowed to modify non-dynamic permission "
3375 mSettings.mPermissions.remove(name);
3376 mSettings.writeLPr();
3381 private static void enforceDeclaredAsUsedAndRuntimePermission(PackageParser.Package pkg,
3382 BasePermission bp) {
3383 int index = pkg.requestedPermissions.indexOf(bp.name);
3385 throw new SecurityException("Package " + pkg.packageName
3386 + " has not requested permission " + bp.name);
3388 if (!bp.isRuntime()) {
3389 throw new SecurityException("Permission " + bp.name
3390 + " is not a changeable permission type");
3395 public void grantRuntimePermission(String packageName, String name, final int userId) {
3396 if (!sUserManager.exists(userId)) {
3397 Log.e(TAG, "No such user:" + userId);
3401 mContext.enforceCallingOrSelfPermission(
3402 android.Manifest.permission.GRANT_REVOKE_PERMISSIONS,
3403 "grantRuntimePermission");
3405 enforceCrossUserPermission(Binder.getCallingUid(), userId, true, false,
3406 "grantRuntimePermission");
3409 final SettingBase sb;
3411 synchronized (mPackages) {
3412 final PackageParser.Package pkg = mPackages.get(packageName);
3414 throw new IllegalArgumentException("Unknown package: " + packageName);
3417 final BasePermission bp = mSettings.mPermissions.get(name);
3419 throw new IllegalArgumentException("Unknown permission: " + name);
3422 enforceDeclaredAsUsedAndRuntimePermission(pkg, bp);
3424 uid = UserHandle.getUid(userId, pkg.applicationInfo.uid);
3425 sb = (SettingBase) pkg.mExtras;
3427 throw new IllegalArgumentException("Unknown package: " + packageName);
3430 final PermissionsState permissionsState = sb.getPermissionsState();
3432 final int flags = permissionsState.getPermissionFlags(name, userId);
3433 if ((flags & PackageManager.FLAG_PERMISSION_SYSTEM_FIXED) != 0) {
3434 throw new SecurityException("Cannot grant system fixed permission: "
3435 + name + " for package: " + packageName);
3438 final int result = permissionsState.grantRuntimePermission(bp, userId);
3440 case PermissionsState.PERMISSION_OPERATION_FAILURE: {
3444 case PermissionsState.PERMISSION_OPERATION_SUCCESS_GIDS_CHANGED: {
3445 mHandler.post(new Runnable() {
3448 killSettingPackagesForUser(sb, userId, KILL_APP_REASON_GIDS_CHANGED);
3454 mOnPermissionChangeListeners.onPermissionsChanged(uid);
3456 // Not critical if that is lost - app has to request again.
3457 mSettings.writeRuntimePermissionsForUserLPr(userId, false);
3460 // Only need to do this if user is initialized. Otherwise it's a new user
3461 // and there are no processes running as the user yet and there's no need
3462 // to make an expensive call to remount processes for the changed permissions.
3463 if (READ_EXTERNAL_STORAGE.equals(name)
3464 || WRITE_EXTERNAL_STORAGE.equals(name)) {
3465 final long token = Binder.clearCallingIdentity();
3467 if (sUserManager.isInitialized(userId)) {
3468 final StorageManager storage = mContext.getSystemService(StorageManager.class);
3469 storage.remountUid(uid);
3472 Binder.restoreCallingIdentity(token);
3478 public void revokeRuntimePermission(String packageName, String name, int userId) {
3479 if (!sUserManager.exists(userId)) {
3480 Log.e(TAG, "No such user:" + userId);
3484 mContext.enforceCallingOrSelfPermission(
3485 android.Manifest.permission.GRANT_REVOKE_PERMISSIONS,
3486 "revokeRuntimePermission");
3488 enforceCrossUserPermission(Binder.getCallingUid(), userId, true, false,
3489 "revokeRuntimePermission");
3491 final SettingBase sb;
3493 synchronized (mPackages) {
3494 final PackageParser.Package pkg = mPackages.get(packageName);
3496 throw new IllegalArgumentException("Unknown package: " + packageName);
3499 final BasePermission bp = mSettings.mPermissions.get(name);
3501 throw new IllegalArgumentException("Unknown permission: " + name);
3504 enforceDeclaredAsUsedAndRuntimePermission(pkg, bp);
3506 sb = (SettingBase) pkg.mExtras;
3508 throw new IllegalArgumentException("Unknown package: " + packageName);
3511 final PermissionsState permissionsState = sb.getPermissionsState();
3513 final int flags = permissionsState.getPermissionFlags(name, userId);
3514 if ((flags & PackageManager.FLAG_PERMISSION_SYSTEM_FIXED) != 0) {
3515 throw new SecurityException("Cannot revoke system fixed permission: "
3516 + name + " for package: " + packageName);
3519 if (permissionsState.revokeRuntimePermission(bp, userId) ==
3520 PermissionsState.PERMISSION_OPERATION_FAILURE) {
3524 mOnPermissionChangeListeners.onPermissionsChanged(pkg.applicationInfo.uid);
3526 // Critical, after this call app should never have the permission.
3527 mSettings.writeRuntimePermissionsForUserLPr(userId, true);
3530 killSettingPackagesForUser(sb, userId, KILL_APP_REASON_PERMISSIONS_REVOKED);
3534 public void resetRuntimePermissions() {
3535 mContext.enforceCallingOrSelfPermission(
3536 android.Manifest.permission.GRANT_REVOKE_PERMISSIONS,
3537 "revokeRuntimePermission");
3539 int callingUid = Binder.getCallingUid();
3540 if (callingUid != Process.SYSTEM_UID && callingUid != 0) {
3541 mContext.enforceCallingOrSelfPermission(
3542 android.Manifest.permission.INTERACT_ACROSS_USERS_FULL,
3543 "resetRuntimePermissions");
3546 final int[] userIds;
3548 synchronized (mPackages) {
3549 updatePermissionsLPw(null, null, UPDATE_PERMISSIONS_ALL);
3550 final int userCount = UserManagerService.getInstance().getUserIds().length;
3551 userIds = Arrays.copyOf(UserManagerService.getInstance().getUserIds(), userCount);
3554 for (int userId : userIds) {
3555 mDefaultPermissionPolicy.grantDefaultPermissions(userId);
3560 public int getPermissionFlags(String name, String packageName, int userId) {
3561 if (!sUserManager.exists(userId)) {
3565 mContext.enforceCallingOrSelfPermission(
3566 android.Manifest.permission.GRANT_REVOKE_PERMISSIONS,
3567 "getPermissionFlags");
3569 enforceCrossUserPermission(Binder.getCallingUid(), userId, true, false,
3570 "getPermissionFlags");
3572 synchronized (mPackages) {
3573 final PackageParser.Package pkg = mPackages.get(packageName);
3575 throw new IllegalArgumentException("Unknown package: " + packageName);
3578 final BasePermission bp = mSettings.mPermissions.get(name);
3580 throw new IllegalArgumentException("Unknown permission: " + name);
3583 SettingBase sb = (SettingBase) pkg.mExtras;
3585 throw new IllegalArgumentException("Unknown package: " + packageName);
3588 PermissionsState permissionsState = sb.getPermissionsState();
3589 return permissionsState.getPermissionFlags(name, userId);
3594 public void updatePermissionFlags(String name, String packageName, int flagMask,
3595 int flagValues, int userId) {
3596 if (!sUserManager.exists(userId)) {
3600 mContext.enforceCallingOrSelfPermission(
3601 android.Manifest.permission.GRANT_REVOKE_PERMISSIONS,
3602 "updatePermissionFlags");
3604 enforceCrossUserPermission(Binder.getCallingUid(), userId, true, false,
3605 "updatePermissionFlags");
3607 // Only the system can change system fixed flags.
3608 if (getCallingUid() != Process.SYSTEM_UID) {
3609 flagMask &= ~PackageManager.FLAG_PERMISSION_SYSTEM_FIXED;
3610 flagValues &= ~PackageManager.FLAG_PERMISSION_SYSTEM_FIXED;
3613 synchronized (mPackages) {
3614 final PackageParser.Package pkg = mPackages.get(packageName);
3616 throw new IllegalArgumentException("Unknown package: " + packageName);
3619 final BasePermission bp = mSettings.mPermissions.get(name);
3621 throw new IllegalArgumentException("Unknown permission: " + name);
3624 SettingBase sb = (SettingBase) pkg.mExtras;
3626 throw new IllegalArgumentException("Unknown package: " + packageName);
3629 PermissionsState permissionsState = sb.getPermissionsState();
3631 // Only the package manager can change flags for system component permissions.
3632 final int flags = permissionsState.getPermissionFlags(bp.name, userId);
3633 if ((flags & PackageManager.FLAG_PERMISSION_SYSTEM_FIXED) != 0) {
3637 boolean hadState = permissionsState.getRuntimePermissionState(name, userId) != null;
3639 if (permissionsState.updatePermissionFlags(bp, userId, flagMask, flagValues)) {
3640 // Install and runtime permissions are stored in different places,
3641 // so figure out what permission changed and persist the change.
3642 if (permissionsState.getInstallPermissionState(name) != null) {
3643 scheduleWriteSettingsLocked();
3644 } else if (permissionsState.getRuntimePermissionState(name, userId) != null
3646 mSettings.writeRuntimePermissionsForUserLPr(userId, false);
3653 * Update the permission flags for all packages and runtime permissions of a user in order
3654 * to allow device or profile owner to remove POLICY_FIXED.
3657 public void updatePermissionFlagsForAllApps(int flagMask, int flagValues, int userId) {
3658 if (!sUserManager.exists(userId)) {
3662 mContext.enforceCallingOrSelfPermission(
3663 android.Manifest.permission.GRANT_REVOKE_PERMISSIONS,
3664 "updatePermissionFlagsForAllApps");
3666 enforceCrossUserPermission(Binder.getCallingUid(), userId, true, false,
3667 "updatePermissionFlagsForAllApps");
3669 // Only the system can change system fixed flags.
3670 if (getCallingUid() != Process.SYSTEM_UID) {
3671 flagMask &= ~PackageManager.FLAG_PERMISSION_SYSTEM_FIXED;
3672 flagValues &= ~PackageManager.FLAG_PERMISSION_SYSTEM_FIXED;
3675 synchronized (mPackages) {
3676 boolean changed = false;
3677 final int packageCount = mPackages.size();
3678 for (int pkgIndex = 0; pkgIndex < packageCount; pkgIndex++) {
3679 final PackageParser.Package pkg = mPackages.valueAt(pkgIndex);
3680 SettingBase sb = (SettingBase) pkg.mExtras;
3684 PermissionsState permissionsState = sb.getPermissionsState();
3685 changed |= permissionsState.updatePermissionFlagsForAllPermissions(
3686 userId, flagMask, flagValues);
3689 mSettings.writeRuntimePermissionsForUserLPr(userId, false);
3695 public boolean shouldShowRequestPermissionRationale(String permissionName,
3696 String packageName, int userId) {
3697 if (UserHandle.getCallingUserId() != userId) {
3698 mContext.enforceCallingPermission(
3699 android.Manifest.permission.INTERACT_ACROSS_USERS_FULL,
3700 "canShowRequestPermissionRationale for user " + userId);
3703 final int uid = getPackageUid(packageName, userId);
3704 if (UserHandle.getAppId(getCallingUid()) != UserHandle.getAppId(uid)) {
3708 if (checkPermission(permissionName, packageName, userId)
3709 == PackageManager.PERMISSION_GRANTED) {
3715 final long identity = Binder.clearCallingIdentity();
3717 flags = getPermissionFlags(permissionName,
3718 packageName, userId);
3720 Binder.restoreCallingIdentity(identity);
3723 final int fixedFlags = PackageManager.FLAG_PERMISSION_SYSTEM_FIXED
3724 | PackageManager.FLAG_PERMISSION_POLICY_FIXED
3725 | PackageManager.FLAG_PERMISSION_USER_FIXED;
3727 if ((flags & fixedFlags) != 0) {
3731 return (flags & PackageManager.FLAG_PERMISSION_USER_SET) != 0;
3734 void grantInstallPermissionLPw(String permission, PackageParser.Package pkg) {
3735 BasePermission bp = mSettings.mPermissions.get(permission);
3737 throw new SecurityException("Missing " + permission + " permission");
3740 SettingBase sb = (SettingBase) pkg.mExtras;
3741 PermissionsState permissionsState = sb.getPermissionsState();
3743 if (permissionsState.grantInstallPermission(bp) !=
3744 PermissionsState.PERMISSION_OPERATION_FAILURE) {
3745 scheduleWriteSettingsLocked();
3750 public void addOnPermissionsChangeListener(IOnPermissionsChangeListener listener) {
3751 mContext.enforceCallingOrSelfPermission(
3752 Manifest.permission.OBSERVE_GRANT_REVOKE_PERMISSIONS,
3753 "addOnPermissionsChangeListener");
3755 synchronized (mPackages) {
3756 mOnPermissionChangeListeners.addListenerLocked(listener);
3761 public void removeOnPermissionsChangeListener(IOnPermissionsChangeListener listener) {
3762 synchronized (mPackages) {
3763 mOnPermissionChangeListeners.removeListenerLocked(listener);
3768 public boolean isProtectedBroadcast(String actionName) {
3769 synchronized (mPackages) {
3770 return mProtectedBroadcasts.contains(actionName);
3775 public int checkSignatures(String pkg1, String pkg2) {
3776 synchronized (mPackages) {
3777 final PackageParser.Package p1 = mPackages.get(pkg1);
3778 final PackageParser.Package p2 = mPackages.get(pkg2);
3779 if (p1 == null || p1.mExtras == null
3780 || p2 == null || p2.mExtras == null) {
3781 return PackageManager.SIGNATURE_UNKNOWN_PACKAGE;
3783 return compareSignatures(p1.mSignatures, p2.mSignatures);
3788 public int checkUidSignatures(int uid1, int uid2) {
3789 // Map to base uids.
3790 uid1 = UserHandle.getAppId(uid1);
3791 uid2 = UserHandle.getAppId(uid2);
3793 synchronized (mPackages) {
3796 Object obj = mSettings.getUserIdLPr(uid1);
3798 if (obj instanceof SharedUserSetting) {
3799 s1 = ((SharedUserSetting)obj).signatures.mSignatures;
3800 } else if (obj instanceof PackageSetting) {
3801 s1 = ((PackageSetting)obj).signatures.mSignatures;
3803 return PackageManager.SIGNATURE_UNKNOWN_PACKAGE;
3806 return PackageManager.SIGNATURE_UNKNOWN_PACKAGE;
3808 obj = mSettings.getUserIdLPr(uid2);
3810 if (obj instanceof SharedUserSetting) {
3811 s2 = ((SharedUserSetting)obj).signatures.mSignatures;
3812 } else if (obj instanceof PackageSetting) {
3813 s2 = ((PackageSetting)obj).signatures.mSignatures;
3815 return PackageManager.SIGNATURE_UNKNOWN_PACKAGE;
3818 return PackageManager.SIGNATURE_UNKNOWN_PACKAGE;
3820 return compareSignatures(s1, s2);
3824 private void killSettingPackagesForUser(SettingBase sb, int userId, String reason) {
3825 final long identity = Binder.clearCallingIdentity();
3827 if (sb instanceof SharedUserSetting) {
3828 SharedUserSetting sus = (SharedUserSetting) sb;
3829 final int packageCount = sus.packages.size();
3830 for (int i = 0; i < packageCount; i++) {
3831 PackageSetting susPs = sus.packages.valueAt(i);
3832 if (userId == UserHandle.USER_ALL) {
3833 killApplication(susPs.pkg.packageName, susPs.appId, reason);
3835 final int uid = UserHandle.getUid(userId, susPs.appId);
3836 killUid(uid, reason);
3839 } else if (sb instanceof PackageSetting) {
3840 PackageSetting ps = (PackageSetting) sb;
3841 if (userId == UserHandle.USER_ALL) {
3842 killApplication(ps.pkg.packageName, ps.appId, reason);
3844 final int uid = UserHandle.getUid(userId, ps.appId);
3845 killUid(uid, reason);
3849 Binder.restoreCallingIdentity(identity);
3853 private static void killUid(int uid, String reason) {
3854 IActivityManager am = ActivityManagerNative.getDefault();
3857 am.killUid(uid, reason);
3858 } catch (RemoteException e) {
3859 /* ignore - same process */
3865 * Compares two sets of signatures. Returns:
3867 * {@link PackageManager#SIGNATURE_NEITHER_SIGNED}: if both signature sets are null,
3869 * {@link PackageManager#SIGNATURE_FIRST_NOT_SIGNED}: if the first signature set is null,
3871 * {@link PackageManager#SIGNATURE_SECOND_NOT_SIGNED}: if the second signature set is null,
3873 * {@link PackageManager#SIGNATURE_MATCH}: if the two signature sets are identical,
3875 * {@link PackageManager#SIGNATURE_NO_MATCH}: if the two signature sets differ.
3877 static int compareSignatures(Signature[] s1, Signature[] s2) {
3880 ? PackageManager.SIGNATURE_NEITHER_SIGNED
3881 : PackageManager.SIGNATURE_FIRST_NOT_SIGNED;
3885 return PackageManager.SIGNATURE_SECOND_NOT_SIGNED;
3888 if (s1.length != s2.length) {
3889 return PackageManager.SIGNATURE_NO_MATCH;
3892 // Since both signature sets are of size 1, we can compare without HashSets.
3893 if (s1.length == 1) {
3894 return s1[0].equals(s2[0]) ?
3895 PackageManager.SIGNATURE_MATCH :
3896 PackageManager.SIGNATURE_NO_MATCH;
3899 ArraySet<Signature> set1 = new ArraySet<Signature>();
3900 for (Signature sig : s1) {
3903 ArraySet<Signature> set2 = new ArraySet<Signature>();
3904 for (Signature sig : s2) {
3907 // Make sure s2 contains all signatures in s1.
3908 if (set1.equals(set2)) {
3909 return PackageManager.SIGNATURE_MATCH;
3911 return PackageManager.SIGNATURE_NO_MATCH;
3915 * If the database version for this type of package (internal storage or
3916 * external storage) is less than the version where package signatures
3917 * were updated, return true.
3919 private boolean isCompatSignatureUpdateNeeded(PackageParser.Package scannedPkg) {
3920 return (isExternal(scannedPkg) && mSettings.isExternalDatabaseVersionOlderThan(
3921 DatabaseVersion.SIGNATURE_END_ENTITY))
3922 || (!isExternal(scannedPkg) && mSettings.isInternalDatabaseVersionOlderThan(
3923 DatabaseVersion.SIGNATURE_END_ENTITY));
3927 * Used for backward compatibility to make sure any packages with
3928 * certificate chains get upgraded to the new style. {@code existingSigs}
3929 * will be in the old format (since they were stored on disk from before the
3930 * system upgrade) and {@code scannedSigs} will be in the newer format.
3932 private int compareSignaturesCompat(PackageSignatures existingSigs,
3933 PackageParser.Package scannedPkg) {
3934 if (!isCompatSignatureUpdateNeeded(scannedPkg)) {
3935 return PackageManager.SIGNATURE_NO_MATCH;
3938 ArraySet<Signature> existingSet = new ArraySet<Signature>();
3939 for (Signature sig : existingSigs.mSignatures) {
3940 existingSet.add(sig);
3942 ArraySet<Signature> scannedCompatSet = new ArraySet<Signature>();
3943 for (Signature sig : scannedPkg.mSignatures) {
3945 Signature[] chainSignatures = sig.getChainSignatures();
3946 for (Signature chainSig : chainSignatures) {
3947 scannedCompatSet.add(chainSig);
3949 } catch (CertificateEncodingException e) {
3950 scannedCompatSet.add(sig);
3954 * Make sure the expanded scanned set contains all signatures in the
3957 if (scannedCompatSet.equals(existingSet)) {
3958 // Migrate the old signatures to the new scheme.
3959 existingSigs.assignSignatures(scannedPkg.mSignatures);
3960 // The new KeySets will be re-added later in the scanning process.
3961 synchronized (mPackages) {
3962 mSettings.mKeySetManagerService.removeAppKeySetDataLPw(scannedPkg.packageName);
3964 return PackageManager.SIGNATURE_MATCH;
3966 return PackageManager.SIGNATURE_NO_MATCH;
3969 private boolean isRecoverSignatureUpdateNeeded(PackageParser.Package scannedPkg) {
3970 if (isExternal(scannedPkg)) {
3971 return mSettings.isExternalDatabaseVersionOlderThan(
3972 DatabaseVersion.SIGNATURE_MALFORMED_RECOVER);
3974 return mSettings.isInternalDatabaseVersionOlderThan(
3975 DatabaseVersion.SIGNATURE_MALFORMED_RECOVER);
3979 private int compareSignaturesRecover(PackageSignatures existingSigs,
3980 PackageParser.Package scannedPkg) {
3981 if (!isRecoverSignatureUpdateNeeded(scannedPkg)) {
3982 return PackageManager.SIGNATURE_NO_MATCH;
3987 if (Signature.areEffectiveMatch(existingSigs.mSignatures, scannedPkg.mSignatures)) {
3988 logCriticalInfo(Log.INFO, "Recovered effectively matching certificates for "
3989 + scannedPkg.packageName);
3990 return PackageManager.SIGNATURE_MATCH;
3992 } catch (CertificateException e) {
3993 msg = e.getMessage();
3996 logCriticalInfo(Log.INFO,
3997 "Failed to recover certificates for " + scannedPkg.packageName + ": " + msg);
3998 return PackageManager.SIGNATURE_NO_MATCH;
4002 public String[] getPackagesForUid(int uid) {
4003 uid = UserHandle.getAppId(uid);
4005 synchronized (mPackages) {
4006 Object obj = mSettings.getUserIdLPr(uid);
4007 if (obj instanceof SharedUserSetting) {
4008 final SharedUserSetting sus = (SharedUserSetting) obj;
4009 final int N = sus.packages.size();
4010 final String[] res = new String[N];
4011 final Iterator<PackageSetting> it = sus.packages.iterator();
4013 while (it.hasNext()) {
4014 res[i++] = it.next().name;
4017 } else if (obj instanceof PackageSetting) {
4018 final PackageSetting ps = (PackageSetting) obj;
4019 return new String[] { ps.name };
4026 public String getNameForUid(int uid) {
4028 synchronized (mPackages) {
4029 Object obj = mSettings.getUserIdLPr(UserHandle.getAppId(uid));
4030 if (obj instanceof SharedUserSetting) {
4031 final SharedUserSetting sus = (SharedUserSetting) obj;
4032 return sus.name + ":" + sus.userId;
4033 } else if (obj instanceof PackageSetting) {
4034 final PackageSetting ps = (PackageSetting) obj;
4042 public int getUidForSharedUser(String sharedUserName) {
4043 if(sharedUserName == null) {
4047 synchronized (mPackages) {
4048 final SharedUserSetting suid = mSettings.getSharedUserLPw(sharedUserName, 0, 0, false);
4057 public int getFlagsForUid(int uid) {
4058 synchronized (mPackages) {
4059 Object obj = mSettings.getUserIdLPr(UserHandle.getAppId(uid));
4060 if (obj instanceof SharedUserSetting) {
4061 final SharedUserSetting sus = (SharedUserSetting) obj;
4062 return sus.pkgFlags;
4063 } else if (obj instanceof PackageSetting) {
4064 final PackageSetting ps = (PackageSetting) obj;
4072 public int getPrivateFlagsForUid(int uid) {
4073 synchronized (mPackages) {
4074 Object obj = mSettings.getUserIdLPr(UserHandle.getAppId(uid));
4075 if (obj instanceof SharedUserSetting) {
4076 final SharedUserSetting sus = (SharedUserSetting) obj;
4077 return sus.pkgPrivateFlags;
4078 } else if (obj instanceof PackageSetting) {
4079 final PackageSetting ps = (PackageSetting) obj;
4080 return ps.pkgPrivateFlags;
4087 public boolean isUidPrivileged(int uid) {
4088 uid = UserHandle.getAppId(uid);
4090 synchronized (mPackages) {
4091 Object obj = mSettings.getUserIdLPr(uid);
4092 if (obj instanceof SharedUserSetting) {
4093 final SharedUserSetting sus = (SharedUserSetting) obj;
4094 final Iterator<PackageSetting> it = sus.packages.iterator();
4095 while (it.hasNext()) {
4096 if (it.next().isPrivileged()) {
4100 } else if (obj instanceof PackageSetting) {
4101 final PackageSetting ps = (PackageSetting) obj;
4102 return ps.isPrivileged();
4109 public String[] getAppOpPermissionPackages(String permissionName) {
4110 synchronized (mPackages) {
4111 ArraySet<String> pkgs = mAppOpPermissionPackages.get(permissionName);
4115 return pkgs.toArray(new String[pkgs.size()]);
4120 public ResolveInfo resolveIntent(Intent intent, String resolvedType,
4121 int flags, int userId) {
4122 if (!sUserManager.exists(userId)) return null;
4123 enforceCrossUserPermission(Binder.getCallingUid(), userId, false, false, "resolve intent");
4124 List<ResolveInfo> query = queryIntentActivities(intent, resolvedType, flags, userId);
4125 return chooseBestActivity(intent, resolvedType, flags, query, userId);
4129 public void setLastChosenActivity(Intent intent, String resolvedType, int flags,
4130 IntentFilter filter, int match, ComponentName activity) {
4131 final int userId = UserHandle.getCallingUserId();
4132 if (DEBUG_PREFERRED) {
4133 Log.v(TAG, "setLastChosenActivity intent=" + intent
4134 + " resolvedType=" + resolvedType
4136 + " filter=" + filter
4138 + " activity=" + activity);
4139 filter.dump(new PrintStreamPrinter(System.out), " ");
4141 intent.setComponent(null);
4142 List<ResolveInfo> query = queryIntentActivities(intent, resolvedType, flags, userId);
4143 // Find any earlier preferred or last chosen entries and nuke them
4144 findPreferredActivity(intent, resolvedType,
4145 flags, query, 0, false, true, false, userId);
4146 // Add the new activity as the last chosen for this filter
4147 addPreferredActivityInternal(filter, match, null, activity, false, userId,
4148 "Setting last chosen");
4152 public ResolveInfo getLastChosenActivity(Intent intent, String resolvedType, int flags) {
4153 final int userId = UserHandle.getCallingUserId();
4154 if (DEBUG_PREFERRED) Log.v(TAG, "Querying last chosen activity for " + intent);
4155 List<ResolveInfo> query = queryIntentActivities(intent, resolvedType, flags, userId);
4156 return findPreferredActivity(intent, resolvedType, flags, query, 0,
4157 false, false, false, userId);
4160 private ResolveInfo chooseBestActivity(Intent intent, String resolvedType,
4161 int flags, List<ResolveInfo> query, int userId) {
4162 if (query != null) {
4163 final int N = query.size();
4165 return query.get(0);
4167 final boolean debug = ((intent.getFlags() & Intent.FLAG_DEBUG_LOG_RESOLUTION) != 0);
4168 // If there is more than one activity with the same priority,
4169 // then let the user decide between them.
4170 ResolveInfo r0 = query.get(0);
4171 ResolveInfo r1 = query.get(1);
4172 if (DEBUG_INTENT_MATCHING || debug) {
4173 Slog.v(TAG, r0.activityInfo.name + "=" + r0.priority + " vs "
4174 + r1.activityInfo.name + "=" + r1.priority);
4176 // If the first activity has a higher priority, or a different
4177 // default, then it is always desireable to pick it.
4178 if (r0.priority != r1.priority
4179 || r0.preferredOrder != r1.preferredOrder
4180 || r0.isDefault != r1.isDefault) {
4181 return query.get(0);
4183 // If we have saved a preference for a preferred activity for
4184 // this Intent, use that.
4185 ResolveInfo ri = findPreferredActivity(intent, resolvedType,
4186 flags, query, r0.priority, true, false, debug, userId);
4191 ri = new ResolveInfo(mResolveInfo);
4192 ri.activityInfo = new ActivityInfo(ri.activityInfo);
4193 ri.activityInfo.applicationInfo = new ApplicationInfo(
4194 ri.activityInfo.applicationInfo);
4195 ri.activityInfo.applicationInfo.uid = UserHandle.getUid(userId,
4196 UserHandle.getAppId(ri.activityInfo.applicationInfo.uid));
4199 return mResolveInfo;
4205 private ResolveInfo findPersistentPreferredActivityLP(Intent intent, String resolvedType,
4206 int flags, List<ResolveInfo> query, boolean debug, int userId) {
4207 final int N = query.size();
4208 PersistentPreferredIntentResolver ppir = mSettings.mPersistentPreferredActivities
4210 // Get the list of persistent preferred activities that handle the intent
4211 if (DEBUG_PREFERRED || debug) Slog.v(TAG, "Looking for presistent preferred activities...");
4212 List<PersistentPreferredActivity> pprefs = ppir != null
4213 ? ppir.queryIntent(intent, resolvedType,
4214 (flags & PackageManager.MATCH_DEFAULT_ONLY) != 0, userId)
4216 if (pprefs != null && pprefs.size() > 0) {
4217 final int M = pprefs.size();
4218 for (int i=0; i<M; i++) {
4219 final PersistentPreferredActivity ppa = pprefs.get(i);
4220 if (DEBUG_PREFERRED || debug) {
4221 Slog.v(TAG, "Checking PersistentPreferredActivity ds="
4222 + (ppa.countDataSchemes() > 0 ? ppa.getDataScheme(0) : "<none>")
4223 + "\n component=" + ppa.mComponent);
4224 ppa.dump(new LogPrinter(Log.VERBOSE, TAG, Log.LOG_ID_SYSTEM), " ");
4226 final ActivityInfo ai = getActivityInfo(ppa.mComponent,
4227 flags | PackageManager.GET_DISABLED_COMPONENTS, userId);
4228 if (DEBUG_PREFERRED || debug) {
4229 Slog.v(TAG, "Found persistent preferred activity:");
4231 ai.dump(new LogPrinter(Log.VERBOSE, TAG, Log.LOG_ID_SYSTEM), " ");
4233 Slog.v(TAG, " null");
4237 // This previously registered persistent preferred activity
4238 // component is no longer known. Ignore it and do NOT remove it.
4241 for (int j=0; j<N; j++) {
4242 final ResolveInfo ri = query.get(j);
4243 if (!ri.activityInfo.applicationInfo.packageName
4244 .equals(ai.applicationInfo.packageName)) {
4247 if (!ri.activityInfo.name.equals(ai.name)) {
4250 // Found a persistent preference that can handle the intent.
4251 if (DEBUG_PREFERRED || debug) {
4252 Slog.v(TAG, "Returning persistent preferred activity: " +
4253 ri.activityInfo.packageName + "/" + ri.activityInfo.name);
4262 ResolveInfo findPreferredActivity(Intent intent, String resolvedType, int flags,
4263 List<ResolveInfo> query, int priority, boolean always,
4264 boolean removeMatches, boolean debug, int userId) {
4265 if (!sUserManager.exists(userId)) return null;
4267 synchronized (mPackages) {
4268 if (intent.getSelector() != null) {
4269 intent = intent.getSelector();
4271 if (DEBUG_PREFERRED) intent.addFlags(Intent.FLAG_DEBUG_LOG_RESOLUTION);
4273 // Try to find a matching persistent preferred activity.
4274 ResolveInfo pri = findPersistentPreferredActivityLP(intent, resolvedType, flags, query,
4277 // If a persistent preferred activity matched, use it.
4282 PreferredIntentResolver pir = mSettings.mPreferredActivities.get(userId);
4283 // Get the list of preferred activities that handle the intent
4284 if (DEBUG_PREFERRED || debug) Slog.v(TAG, "Looking for preferred activities...");
4285 List<PreferredActivity> prefs = pir != null
4286 ? pir.queryIntent(intent, resolvedType,
4287 (flags & PackageManager.MATCH_DEFAULT_ONLY) != 0, userId)
4289 if (prefs != null && prefs.size() > 0) {
4290 boolean changed = false;
4292 // First figure out how good the original match set is.
4293 // We will only allow preferred activities that came
4294 // from the same match quality.
4297 if (DEBUG_PREFERRED || debug) Slog.v(TAG, "Figuring out best match...");
4299 final int N = query.size();
4300 for (int j=0; j<N; j++) {
4301 final ResolveInfo ri = query.get(j);
4302 if (DEBUG_PREFERRED || debug) Slog.v(TAG, "Match for " + ri.activityInfo
4303 + ": 0x" + Integer.toHexString(match));
4304 if (ri.match > match) {
4309 if (DEBUG_PREFERRED || debug) Slog.v(TAG, "Best match: 0x"
4310 + Integer.toHexString(match));
4312 match &= IntentFilter.MATCH_CATEGORY_MASK;
4313 final int M = prefs.size();
4314 for (int i=0; i<M; i++) {
4315 final PreferredActivity pa = prefs.get(i);
4316 if (DEBUG_PREFERRED || debug) {
4317 Slog.v(TAG, "Checking PreferredActivity ds="
4318 + (pa.countDataSchemes() > 0 ? pa.getDataScheme(0) : "<none>")
4319 + "\n component=" + pa.mPref.mComponent);
4320 pa.dump(new LogPrinter(Log.VERBOSE, TAG, Log.LOG_ID_SYSTEM), " ");
4322 if (pa.mPref.mMatch != match) {
4323 if (DEBUG_PREFERRED || debug) Slog.v(TAG, "Skipping bad match "
4324 + Integer.toHexString(pa.mPref.mMatch));
4327 // If it's not an "always" type preferred activity and that's what we're
4328 // looking for, skip it.
4329 if (always && !pa.mPref.mAlways) {
4330 if (DEBUG_PREFERRED || debug) Slog.v(TAG, "Skipping mAlways=false entry");
4333 final ActivityInfo ai = getActivityInfo(pa.mPref.mComponent,
4334 flags | PackageManager.GET_DISABLED_COMPONENTS, userId);
4335 if (DEBUG_PREFERRED || debug) {
4336 Slog.v(TAG, "Found preferred activity:");
4338 ai.dump(new LogPrinter(Log.VERBOSE, TAG, Log.LOG_ID_SYSTEM), " ");
4340 Slog.v(TAG, " null");
4344 // This previously registered preferred activity
4345 // component is no longer known. Most likely an update
4346 // to the app was installed and in the new version this
4347 // component no longer exists. Clean it up by removing
4348 // it from the preferred activities list, and skip it.
4349 Slog.w(TAG, "Removing dangling preferred activity: "
4350 + pa.mPref.mComponent);
4351 pir.removeFilter(pa);
4355 for (int j=0; j<N; j++) {
4356 final ResolveInfo ri = query.get(j);
4357 if (!ri.activityInfo.applicationInfo.packageName
4358 .equals(ai.applicationInfo.packageName)) {
4361 if (!ri.activityInfo.name.equals(ai.name)) {
4365 if (removeMatches) {
4366 pir.removeFilter(pa);
4368 if (DEBUG_PREFERRED) {
4369 Slog.v(TAG, "Removing match " + pa.mPref.mComponent);
4374 // Okay we found a previously set preferred or last chosen app.
4375 // If the result set is different from when this
4376 // was created, we need to clear it and re-ask the
4377 // user their preference, if we're looking for an "always" type entry.
4378 if (always && !pa.mPref.sameSet(query)) {
4379 Slog.i(TAG, "Result set changed, dropping preferred activity for "
4380 + intent + " type " + resolvedType);
4381 if (DEBUG_PREFERRED) {
4382 Slog.v(TAG, "Removing preferred activity since set changed "
4383 + pa.mPref.mComponent);
4385 pir.removeFilter(pa);
4386 // Re-add the filter as a "last chosen" entry (!always)
4387 PreferredActivity lastChosen = new PreferredActivity(
4388 pa, pa.mPref.mMatch, null, pa.mPref.mComponent, false);
4389 pir.addFilter(lastChosen);
4394 // Yay! Either the set matched or we're looking for the last chosen
4395 if (DEBUG_PREFERRED || debug) Slog.v(TAG, "Returning preferred activity: "
4396 + ri.activityInfo.packageName + "/" + ri.activityInfo.name);
4402 if (DEBUG_PREFERRED) {
4403 Slog.v(TAG, "Preferred activity bookkeeping changed; writing restrictions");
4405 scheduleWritePackageRestrictionsLocked(userId);
4410 if (DEBUG_PREFERRED || debug) Slog.v(TAG, "No preferred activity to return");
4415 * Returns if intent can be forwarded from the sourceUserId to the targetUserId
4418 public boolean canForwardTo(Intent intent, String resolvedType, int sourceUserId,
4420 mContext.enforceCallingOrSelfPermission(
4421 android.Manifest.permission.INTERACT_ACROSS_USERS_FULL, null);
4422 List<CrossProfileIntentFilter> matches =
4423 getMatchingCrossProfileIntentFilters(intent, resolvedType, sourceUserId);
4424 if (matches != null) {
4425 int size = matches.size();
4426 for (int i = 0; i < size; i++) {
4427 if (matches.get(i).getTargetUserId() == targetUserId) return true;
4430 if (hasWebURI(intent)) {
4431 // cross-profile app linking works only towards the parent.
4432 final UserInfo parent = getProfileParent(sourceUserId);
4433 synchronized(mPackages) {
4434 CrossProfileDomainInfo xpDomainInfo = getCrossProfileDomainPreferredLpr(
4435 intent, resolvedType, 0, sourceUserId, parent.id);
4436 return xpDomainInfo != null
4437 && xpDomainInfo.bestDomainVerificationStatus !=
4438 INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_NEVER;
4444 private UserInfo getProfileParent(int userId) {
4445 final long identity = Binder.clearCallingIdentity();
4447 return sUserManager.getProfileParent(userId);
4449 Binder.restoreCallingIdentity(identity);
4453 private List<CrossProfileIntentFilter> getMatchingCrossProfileIntentFilters(Intent intent,
4454 String resolvedType, int userId) {
4455 CrossProfileIntentResolver resolver = mSettings.mCrossProfileIntentResolvers.get(userId);
4456 if (resolver != null) {
4457 return resolver.queryIntent(intent, resolvedType, false, userId);
4463 public List<ResolveInfo> queryIntentActivities(Intent intent,
4464 String resolvedType, int flags, int userId) {
4465 if (!sUserManager.exists(userId)) return Collections.emptyList();
4466 enforceCrossUserPermission(Binder.getCallingUid(), userId, false, false, "query intent activities");
4467 ComponentName comp = intent.getComponent();
4469 if (intent.getSelector() != null) {
4470 intent = intent.getSelector();
4471 comp = intent.getComponent();
4476 final List<ResolveInfo> list = new ArrayList<ResolveInfo>(1);
4477 final ActivityInfo ai = getActivityInfo(comp, flags, userId);
4479 final ResolveInfo ri = new ResolveInfo();
4480 ri.activityInfo = ai;
4487 synchronized (mPackages) {
4488 final String pkgName = intent.getPackage();
4489 if (pkgName == null) {
4490 List<CrossProfileIntentFilter> matchingFilters =
4491 getMatchingCrossProfileIntentFilters(intent, resolvedType, userId);
4492 // Check for results that need to skip the current profile.
4493 ResolveInfo xpResolveInfo = querySkipCurrentProfileIntents(matchingFilters, intent,
4494 resolvedType, flags, userId);
4495 if (xpResolveInfo != null && isUserEnabled(xpResolveInfo.targetUserId)) {
4496 List<ResolveInfo> result = new ArrayList<ResolveInfo>(1);
4497 result.add(xpResolveInfo);
4498 return filterIfNotPrimaryUser(result, userId);
4501 // Check for results in the current profile.
4502 List<ResolveInfo> result = mActivities.queryIntent(
4503 intent, resolvedType, flags, userId);
4505 // Check for cross profile results.
4506 xpResolveInfo = queryCrossProfileIntents(
4507 matchingFilters, intent, resolvedType, flags, userId);
4508 if (xpResolveInfo != null && isUserEnabled(xpResolveInfo.targetUserId)) {
4509 result.add(xpResolveInfo);
4510 Collections.sort(result, mResolvePrioritySorter);
4512 result = filterIfNotPrimaryUser(result, userId);
4513 if (hasWebURI(intent)) {
4514 CrossProfileDomainInfo xpDomainInfo = null;
4515 final UserInfo parent = getProfileParent(userId);
4516 if (parent != null) {
4517 xpDomainInfo = getCrossProfileDomainPreferredLpr(intent, resolvedType,
4518 flags, userId, parent.id);
4520 if (xpDomainInfo != null) {
4521 if (xpResolveInfo != null) {
4522 // If we didn't remove it, the cross-profile ResolveInfo would be twice
4524 result.remove(xpResolveInfo);
4526 if (result.size() == 0) {
4527 result.add(xpDomainInfo.resolveInfo);
4530 } else if (result.size() <= 1) {
4533 result = filterCandidatesWithDomainPreferredActivitiesLPr(flags, result,
4534 xpDomainInfo, userId);
4535 Collections.sort(result, mResolvePrioritySorter);
4539 final PackageParser.Package pkg = mPackages.get(pkgName);
4541 return filterIfNotPrimaryUser(
4542 mActivities.queryIntentForPackage(
4543 intent, resolvedType, flags, pkg.activities, userId),
4546 return new ArrayList<ResolveInfo>();
4550 private static class CrossProfileDomainInfo {
4551 /* ResolveInfo for IntentForwarderActivity to send the intent to the other profile */
4552 ResolveInfo resolveInfo;
4553 /* Best domain verification status of the activities found in the other profile */
4554 int bestDomainVerificationStatus;
4557 private CrossProfileDomainInfo getCrossProfileDomainPreferredLpr(Intent intent,
4558 String resolvedType, int flags, int sourceUserId, int parentUserId) {
4559 if (!sUserManager.hasUserRestriction(UserManager.ALLOW_PARENT_PROFILE_APP_LINKING,
4563 List<ResolveInfo> resultTargetUser = mActivities.queryIntent(intent,
4564 resolvedType, flags, parentUserId);
4566 if (resultTargetUser == null || resultTargetUser.isEmpty()) {
4569 CrossProfileDomainInfo result = null;
4570 int size = resultTargetUser.size();
4571 for (int i = 0; i < size; i++) {
4572 ResolveInfo riTargetUser = resultTargetUser.get(i);
4573 // Intent filter verification is only for filters that specify a host. So don't return
4574 // those that handle all web uris.
4575 if (riTargetUser.handleAllWebDataURI) {
4578 String packageName = riTargetUser.activityInfo.packageName;
4579 PackageSetting ps = mSettings.mPackages.get(packageName);
4583 long verificationState = getDomainVerificationStatusLPr(ps, parentUserId);
4584 int status = (int)(verificationState >> 32);
4585 if (result == null) {
4586 result = new CrossProfileDomainInfo();
4587 result.resolveInfo =
4588 createForwardingResolveInfo(null, sourceUserId, parentUserId);
4589 result.bestDomainVerificationStatus = status;
4591 result.bestDomainVerificationStatus = bestDomainVerificationStatus(status,
4592 result.bestDomainVerificationStatus);
4599 * Verification statuses are ordered from the worse to the best, except for
4600 * INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_NEVER, which is the worse.
4602 private int bestDomainVerificationStatus(int status1, int status2) {
4603 if (status1 == INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_NEVER) {
4606 if (status2 == INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_NEVER) {
4609 return (int) MathUtils.max(status1, status2);
4612 private boolean isUserEnabled(int userId) {
4613 long callingId = Binder.clearCallingIdentity();
4615 UserInfo userInfo = sUserManager.getUserInfo(userId);
4616 return userInfo != null && userInfo.isEnabled();
4618 Binder.restoreCallingIdentity(callingId);
4623 * Filter out activities with primaryUserOnly flag set, when current user is not the owner.
4625 * @return filtered list
4627 private List<ResolveInfo> filterIfNotPrimaryUser(List<ResolveInfo> resolveInfos, int userId) {
4628 if (userId == UserHandle.USER_OWNER) {
4629 return resolveInfos;
4631 for (int i = resolveInfos.size() - 1; i >= 0; i--) {
4632 ResolveInfo info = resolveInfos.get(i);
4633 if ((info.activityInfo.flags & ActivityInfo.FLAG_PRIMARY_USER_ONLY) != 0) {
4634 resolveInfos.remove(i);
4637 return resolveInfos;
4640 private static boolean hasWebURI(Intent intent) {
4641 if (intent.getData() == null) {
4644 final String scheme = intent.getScheme();
4645 if (TextUtils.isEmpty(scheme)) {
4648 return scheme.equals(IntentFilter.SCHEME_HTTP) || scheme.equals(IntentFilter.SCHEME_HTTPS);
4651 private List<ResolveInfo> filterCandidatesWithDomainPreferredActivitiesLPr(
4652 int flags, List<ResolveInfo> candidates, CrossProfileDomainInfo xpDomainInfo,
4654 if (DEBUG_PREFERRED || DEBUG_DOMAIN_VERIFICATION) {
4655 Slog.v(TAG, "Filtering results with preferred activities. Candidates count: " +
4659 ArrayList<ResolveInfo> result = new ArrayList<ResolveInfo>();
4660 ArrayList<ResolveInfo> alwaysList = new ArrayList<ResolveInfo>();
4661 ArrayList<ResolveInfo> undefinedList = new ArrayList<ResolveInfo>();
4662 ArrayList<ResolveInfo> neverList = new ArrayList<ResolveInfo>();
4663 ArrayList<ResolveInfo> matchAllList = new ArrayList<ResolveInfo>();
4665 synchronized (mPackages) {
4666 final int count = candidates.size();
4667 // First, try to use linked apps. Partition the candidates into four lists:
4668 // one for the final results, one for the "do not use ever", one for "undefined status"
4669 // and finally one for "browser app type".
4670 for (int n=0; n<count; n++) {
4671 ResolveInfo info = candidates.get(n);
4672 String packageName = info.activityInfo.packageName;
4673 PackageSetting ps = mSettings.mPackages.get(packageName);
4675 // Add to the special match all list (Browser use case)
4676 if (info.handleAllWebDataURI) {
4677 matchAllList.add(info);
4680 // Try to get the status from User settings first
4681 long packedStatus = getDomainVerificationStatusLPr(ps, userId);
4682 int status = (int)(packedStatus >> 32);
4683 int linkGeneration = (int)(packedStatus & 0xFFFFFFFF);
4684 if (status == INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_ALWAYS) {
4685 if (DEBUG_DOMAIN_VERIFICATION) {
4686 Slog.i(TAG, " + always: " + info.activityInfo.packageName
4687 + " : linkgen=" + linkGeneration);
4689 // Use link-enabled generation as preferredOrder, i.e.
4690 // prefer newly-enabled over earlier-enabled.
4691 info.preferredOrder = linkGeneration;
4692 alwaysList.add(info);
4693 } else if (status == INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_NEVER) {
4694 if (DEBUG_DOMAIN_VERIFICATION) {
4695 Slog.i(TAG, " + never: " + info.activityInfo.packageName);
4697 neverList.add(info);
4698 } else if (status == INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_UNDEFINED ||
4699 status == INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_ASK) {
4700 if (DEBUG_DOMAIN_VERIFICATION) {
4701 Slog.i(TAG, " + ask: " + info.activityInfo.packageName);
4703 undefinedList.add(info);
4707 // First try to add the "always" resolution(s) for the current user, if any
4708 if (alwaysList.size() > 0) {
4709 result.addAll(alwaysList);
4710 // if there is an "always" for the parent user, add it.
4711 } else if (xpDomainInfo != null && xpDomainInfo.bestDomainVerificationStatus
4712 == INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_ALWAYS) {
4713 result.add(xpDomainInfo.resolveInfo);
4715 // Add all undefined Apps as we want them to appear in the Disambiguation dialog.
4716 result.addAll(undefinedList);
4717 if (xpDomainInfo != null && (
4718 xpDomainInfo.bestDomainVerificationStatus
4719 == INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_UNDEFINED
4720 || xpDomainInfo.bestDomainVerificationStatus
4721 == INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_ASK)) {
4722 result.add(xpDomainInfo.resolveInfo);
4724 // Also add Browsers (all of them or only the default one)
4725 if ((flags & MATCH_ALL) != 0) {
4726 result.addAll(matchAllList);
4728 // Try to add the Default Browser if we can
4729 final String defaultBrowserPackageName = getDefaultBrowserPackageName(
4730 UserHandle.myUserId());
4731 if (!TextUtils.isEmpty(defaultBrowserPackageName)) {
4732 boolean defaultBrowserFound = false;
4733 final int browserCount = matchAllList.size();
4734 for (int n=0; n<browserCount; n++) {
4735 ResolveInfo browser = matchAllList.get(n);
4736 if (browser.activityInfo.packageName.equals(defaultBrowserPackageName)) {
4737 result.add(browser);
4738 defaultBrowserFound = true;
4742 if (!defaultBrowserFound) {
4743 result.addAll(matchAllList);
4746 result.addAll(matchAllList);
4750 // If there is nothing selected, add all candidates and remove the ones that the user
4751 // has explicitly put into the INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_NEVER state
4752 if (result.size() == 0) {
4753 result.addAll(candidates);
4754 result.removeAll(neverList);
4758 if (DEBUG_PREFERRED || DEBUG_DOMAIN_VERIFICATION) {
4759 Slog.v(TAG, "Filtered results with preferred activities. New candidates count: " +
4761 for (ResolveInfo info : result) {
4762 Slog.v(TAG, " + " + info.activityInfo);
4768 // Returns a packed value as a long:
4770 // high 'int'-sized word: link status: undefined/ask/never/always.
4771 // low 'int'-sized word: relative priority among 'always' results.
4772 private long getDomainVerificationStatusLPr(PackageSetting ps, int userId) {
4773 long result = ps.getDomainVerificationStatusForUser(userId);
4774 // if none available, get the master status
4775 if (result >> 32 == INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_UNDEFINED) {
4776 if (ps.getIntentFilterVerificationInfo() != null) {
4777 result = ((long)ps.getIntentFilterVerificationInfo().getStatus()) << 32;
4783 private ResolveInfo querySkipCurrentProfileIntents(
4784 List<CrossProfileIntentFilter> matchingFilters, Intent intent, String resolvedType,
4785 int flags, int sourceUserId) {
4786 if (matchingFilters != null) {
4787 int size = matchingFilters.size();
4788 for (int i = 0; i < size; i ++) {
4789 CrossProfileIntentFilter filter = matchingFilters.get(i);
4790 if ((filter.getFlags() & PackageManager.SKIP_CURRENT_PROFILE) != 0) {
4791 // Checking if there are activities in the target user that can handle the
4793 ResolveInfo resolveInfo = checkTargetCanHandle(filter, intent, resolvedType,
4794 flags, sourceUserId);
4795 if (resolveInfo != null) {
4804 // Return matching ResolveInfo if any for skip current profile intent filters.
4805 private ResolveInfo queryCrossProfileIntents(
4806 List<CrossProfileIntentFilter> matchingFilters, Intent intent, String resolvedType,
4807 int flags, int sourceUserId) {
4808 if (matchingFilters != null) {
4809 // Two {@link CrossProfileIntentFilter}s can have the same targetUserId and
4810 // match the same intent. For performance reasons, it is better not to
4811 // run queryIntent twice for the same userId
4812 SparseBooleanArray alreadyTriedUserIds = new SparseBooleanArray();
4813 int size = matchingFilters.size();
4814 for (int i = 0; i < size; i++) {
4815 CrossProfileIntentFilter filter = matchingFilters.get(i);
4816 int targetUserId = filter.getTargetUserId();
4817 if ((filter.getFlags() & PackageManager.SKIP_CURRENT_PROFILE) == 0
4818 && !alreadyTriedUserIds.get(targetUserId)) {
4819 // Checking if there are activities in the target user that can handle the
4821 ResolveInfo resolveInfo = checkTargetCanHandle(filter, intent, resolvedType,
4822 flags, sourceUserId);
4823 if (resolveInfo != null) return resolveInfo;
4824 alreadyTriedUserIds.put(targetUserId, true);
4831 private ResolveInfo checkTargetCanHandle(CrossProfileIntentFilter filter, Intent intent,
4832 String resolvedType, int flags, int sourceUserId) {
4833 List<ResolveInfo> resultTargetUser = mActivities.queryIntent(intent,
4834 resolvedType, flags, filter.getTargetUserId());
4835 if (resultTargetUser != null && !resultTargetUser.isEmpty()) {
4836 return createForwardingResolveInfo(filter, sourceUserId, filter.getTargetUserId());
4841 private ResolveInfo createForwardingResolveInfo(IntentFilter filter,
4842 int sourceUserId, int targetUserId) {
4843 ResolveInfo forwardingResolveInfo = new ResolveInfo();
4845 if (targetUserId == UserHandle.USER_OWNER) {
4846 className = FORWARD_INTENT_TO_USER_OWNER;
4848 className = FORWARD_INTENT_TO_MANAGED_PROFILE;
4850 ComponentName forwardingActivityComponentName = new ComponentName(
4851 mAndroidApplication.packageName, className);
4852 ActivityInfo forwardingActivityInfo = getActivityInfo(forwardingActivityComponentName, 0,
4854 if (targetUserId == UserHandle.USER_OWNER) {
4855 forwardingActivityInfo.showUserIcon = UserHandle.USER_OWNER;
4856 forwardingResolveInfo.noResourceId = true;
4858 forwardingResolveInfo.activityInfo = forwardingActivityInfo;
4859 forwardingResolveInfo.priority = 0;
4860 forwardingResolveInfo.preferredOrder = 0;
4861 forwardingResolveInfo.match = 0;
4862 forwardingResolveInfo.isDefault = true;
4863 forwardingResolveInfo.filter = filter;
4864 forwardingResolveInfo.targetUserId = targetUserId;
4865 return forwardingResolveInfo;
4869 public List<ResolveInfo> queryIntentActivityOptions(ComponentName caller,
4870 Intent[] specifics, String[] specificTypes, Intent intent,
4871 String resolvedType, int flags, int userId) {
4872 if (!sUserManager.exists(userId)) return Collections.emptyList();
4873 enforceCrossUserPermission(Binder.getCallingUid(), userId, false,
4874 false, "query intent activity options");
4875 final String resultsAction = intent.getAction();
4877 List<ResolveInfo> results = queryIntentActivities(intent, resolvedType, flags
4878 | PackageManager.GET_RESOLVED_FILTER, userId);
4880 if (DEBUG_INTENT_MATCHING) {
4881 Log.v(TAG, "Query " + intent + ": " + results);
4884 int specificsPos = 0;
4887 // todo: note that the algorithm used here is O(N^2). This
4888 // isn't a problem in our current environment, but if we start running
4889 // into situations where we have more than 5 or 10 matches then this
4890 // should probably be changed to something smarter...
4892 // First we go through and resolve each of the specific items
4893 // that were supplied, taking care of removing any corresponding
4894 // duplicate items in the generic resolve list.
4895 if (specifics != null) {
4896 for (int i=0; i<specifics.length; i++) {
4897 final Intent sintent = specifics[i];
4898 if (sintent == null) {
4902 if (DEBUG_INTENT_MATCHING) {
4903 Log.v(TAG, "Specific #" + i + ": " + sintent);
4906 String action = sintent.getAction();
4907 if (resultsAction != null && resultsAction.equals(action)) {
4908 // If this action was explicitly requested, then don't
4909 // remove things that have it.
4913 ResolveInfo ri = null;
4914 ActivityInfo ai = null;
4916 ComponentName comp = sintent.getComponent();
4920 specificTypes != null ? specificTypes[i] : null,
4925 if (ri == mResolveInfo) {
4926 // ACK! Must do something better with this.
4928 ai = ri.activityInfo;
4929 comp = new ComponentName(ai.applicationInfo.packageName,
4932 ai = getActivityInfo(comp, flags, userId);
4938 // Look for any generic query activities that are duplicates
4939 // of this specific one, and remove them from the results.
4940 if (DEBUG_INTENT_MATCHING) Log.v(TAG, "Specific #" + i + ": " + ai);
4943 for (j=specificsPos; j<N; j++) {
4944 ResolveInfo sri = results.get(j);
4945 if ((sri.activityInfo.name.equals(comp.getClassName())
4946 && sri.activityInfo.applicationInfo.packageName.equals(
4947 comp.getPackageName()))
4948 || (action != null && sri.filter.matchAction(action))) {
4950 if (DEBUG_INTENT_MATCHING) Log.v(
4951 TAG, "Removing duplicate item from " + j
4952 + " due to specific " + specificsPos);
4961 // Add this specific item to its proper place.
4963 ri = new ResolveInfo();
4964 ri.activityInfo = ai;
4966 results.add(specificsPos, ri);
4967 ri.specificIndex = i;
4972 // Now we go through the remaining generic results and remove any
4973 // duplicate actions that are found here.
4975 for (int i=specificsPos; i<N-1; i++) {
4976 final ResolveInfo rii = results.get(i);
4977 if (rii.filter == null) {
4981 // Iterate over all of the actions of this result's intent
4982 // filter... typically this should be just one.
4983 final Iterator<String> it = rii.filter.actionsIterator();
4987 while (it.hasNext()) {
4988 final String action = it.next();
4989 if (resultsAction != null && resultsAction.equals(action)) {
4990 // If this action was explicitly requested, then don't
4991 // remove things that have it.
4994 for (int j=i+1; j<N; j++) {
4995 final ResolveInfo rij = results.get(j);
4996 if (rij.filter != null && rij.filter.hasAction(action)) {
4998 if (DEBUG_INTENT_MATCHING) Log.v(
4999 TAG, "Removing duplicate item from " + j
5000 + " due to action " + action + " at " + i);
5007 // If the caller didn't request filter information, drop it now
5008 // so we don't have to marshall/unmarshall it.
5009 if ((flags&PackageManager.GET_RESOLVED_FILTER) == 0) {
5014 // Filter out the caller activity if so requested.
5015 if (caller != null) {
5017 for (int i=0; i<N; i++) {
5018 ActivityInfo ainfo = results.get(i).activityInfo;
5019 if (caller.getPackageName().equals(ainfo.applicationInfo.packageName)
5020 && caller.getClassName().equals(ainfo.name)) {
5027 // If the caller didn't request filter information,
5028 // drop them now so we don't have to
5029 // marshall/unmarshall it.
5030 if ((flags&PackageManager.GET_RESOLVED_FILTER) == 0) {
5032 for (int i=0; i<N; i++) {
5033 results.get(i).filter = null;
5037 if (DEBUG_INTENT_MATCHING) Log.v(TAG, "Result: " + results);
5042 public List<ResolveInfo> queryIntentReceivers(Intent intent, String resolvedType, int flags,
5044 if (!sUserManager.exists(userId)) return Collections.emptyList();
5045 ComponentName comp = intent.getComponent();
5047 if (intent.getSelector() != null) {
5048 intent = intent.getSelector();
5049 comp = intent.getComponent();
5053 List<ResolveInfo> list = new ArrayList<ResolveInfo>(1);
5054 ActivityInfo ai = getReceiverInfo(comp, flags, userId);
5056 ResolveInfo ri = new ResolveInfo();
5057 ri.activityInfo = ai;
5064 synchronized (mPackages) {
5065 String pkgName = intent.getPackage();
5066 if (pkgName == null) {
5067 return mReceivers.queryIntent(intent, resolvedType, flags, userId);
5069 final PackageParser.Package pkg = mPackages.get(pkgName);
5071 return mReceivers.queryIntentForPackage(intent, resolvedType, flags, pkg.receivers,
5079 public ResolveInfo resolveService(Intent intent, String resolvedType, int flags, int userId) {
5080 List<ResolveInfo> query = queryIntentServices(intent, resolvedType, flags, userId);
5081 if (!sUserManager.exists(userId)) return null;
5082 if (query != null) {
5083 if (query.size() >= 1) {
5084 // If there is more than one service with the same priority,
5085 // just arbitrarily pick the first one.
5086 return query.get(0);
5093 public List<ResolveInfo> queryIntentServices(Intent intent, String resolvedType, int flags,
5095 if (!sUserManager.exists(userId)) return Collections.emptyList();
5096 ComponentName comp = intent.getComponent();
5098 if (intent.getSelector() != null) {
5099 intent = intent.getSelector();
5100 comp = intent.getComponent();
5104 final List<ResolveInfo> list = new ArrayList<ResolveInfo>(1);
5105 final ServiceInfo si = getServiceInfo(comp, flags, userId);
5107 final ResolveInfo ri = new ResolveInfo();
5108 ri.serviceInfo = si;
5115 synchronized (mPackages) {
5116 String pkgName = intent.getPackage();
5117 if (pkgName == null) {
5118 return mServices.queryIntent(intent, resolvedType, flags, userId);
5120 final PackageParser.Package pkg = mPackages.get(pkgName);
5122 return mServices.queryIntentForPackage(intent, resolvedType, flags, pkg.services,
5130 public List<ResolveInfo> queryIntentContentProviders(
5131 Intent intent, String resolvedType, int flags, int userId) {
5132 if (!sUserManager.exists(userId)) return Collections.emptyList();
5133 ComponentName comp = intent.getComponent();
5135 if (intent.getSelector() != null) {
5136 intent = intent.getSelector();
5137 comp = intent.getComponent();
5141 final List<ResolveInfo> list = new ArrayList<ResolveInfo>(1);
5142 final ProviderInfo pi = getProviderInfo(comp, flags, userId);
5144 final ResolveInfo ri = new ResolveInfo();
5145 ri.providerInfo = pi;
5152 synchronized (mPackages) {
5153 String pkgName = intent.getPackage();
5154 if (pkgName == null) {
5155 return mProviders.queryIntent(intent, resolvedType, flags, userId);
5157 final PackageParser.Package pkg = mPackages.get(pkgName);
5159 return mProviders.queryIntentForPackage(
5160 intent, resolvedType, flags, pkg.providers, userId);
5167 public ParceledListSlice<PackageInfo> getInstalledPackages(int flags, int userId) {
5168 final boolean listUninstalled = (flags & PackageManager.GET_UNINSTALLED_PACKAGES) != 0;
5170 enforceCrossUserPermission(Binder.getCallingUid(), userId, true, false, "get installed packages");
5173 synchronized (mPackages) {
5174 ArrayList<PackageInfo> list;
5175 if (listUninstalled) {
5176 list = new ArrayList<PackageInfo>(mSettings.mPackages.size());
5177 for (PackageSetting ps : mSettings.mPackages.values()) {
5179 if (ps.pkg != null) {
5180 pi = generatePackageInfo(ps.pkg, flags, userId);
5182 pi = generatePackageInfoFromSettingsLPw(ps.name, flags, userId);
5189 list = new ArrayList<PackageInfo>(mPackages.size());
5190 for (PackageParser.Package p : mPackages.values()) {
5191 PackageInfo pi = generatePackageInfo(p, flags, userId);
5198 return new ParceledListSlice<PackageInfo>(list);
5202 private void addPackageHoldingPermissions(ArrayList<PackageInfo> list, PackageSetting ps,
5203 String[] permissions, boolean[] tmp, int flags, int userId) {
5205 final PermissionsState permissionsState = ps.getPermissionsState();
5206 for (int i=0; i<permissions.length; i++) {
5207 final String permission = permissions[i];
5208 if (permissionsState.hasPermission(permission, userId)) {
5215 if (numMatch == 0) {
5219 if (ps.pkg != null) {
5220 pi = generatePackageInfo(ps.pkg, flags, userId);
5222 pi = generatePackageInfoFromSettingsLPw(ps.name, flags, userId);
5224 // The above might return null in cases of uninstalled apps or install-state
5225 // skew across users/profiles.
5227 if ((flags&PackageManager.GET_PERMISSIONS) == 0) {
5228 if (numMatch == permissions.length) {
5229 pi.requestedPermissions = permissions;
5231 pi.requestedPermissions = new String[numMatch];
5233 for (int i=0; i<permissions.length; i++) {
5235 pi.requestedPermissions[numMatch] = permissions[i];
5246 public ParceledListSlice<PackageInfo> getPackagesHoldingPermissions(
5247 String[] permissions, int flags, int userId) {
5248 if (!sUserManager.exists(userId)) return null;
5249 final boolean listUninstalled = (flags & PackageManager.GET_UNINSTALLED_PACKAGES) != 0;
5252 synchronized (mPackages) {
5253 ArrayList<PackageInfo> list = new ArrayList<PackageInfo>();
5254 boolean[] tmpBools = new boolean[permissions.length];
5255 if (listUninstalled) {
5256 for (PackageSetting ps : mSettings.mPackages.values()) {
5257 addPackageHoldingPermissions(list, ps, permissions, tmpBools, flags, userId);
5260 for (PackageParser.Package pkg : mPackages.values()) {
5261 PackageSetting ps = (PackageSetting)pkg.mExtras;
5263 addPackageHoldingPermissions(list, ps, permissions, tmpBools, flags,
5269 return new ParceledListSlice<PackageInfo>(list);
5274 public ParceledListSlice<ApplicationInfo> getInstalledApplications(int flags, int userId) {
5275 if (!sUserManager.exists(userId)) return null;
5276 final boolean listUninstalled = (flags & PackageManager.GET_UNINSTALLED_PACKAGES) != 0;
5279 synchronized (mPackages) {
5280 ArrayList<ApplicationInfo> list;
5281 if (listUninstalled) {
5282 list = new ArrayList<ApplicationInfo>(mSettings.mPackages.size());
5283 for (PackageSetting ps : mSettings.mPackages.values()) {
5285 if (ps.pkg != null) {
5286 ai = PackageParser.generateApplicationInfo(ps.pkg, flags,
5287 ps.readUserState(userId), userId);
5289 ai = generateApplicationInfoFromSettingsLPw(ps.name, flags, userId);
5296 list = new ArrayList<ApplicationInfo>(mPackages.size());
5297 for (PackageParser.Package p : mPackages.values()) {
5298 if (p.mExtras != null) {
5299 ApplicationInfo ai = PackageParser.generateApplicationInfo(p, flags,
5300 ((PackageSetting)p.mExtras).readUserState(userId), userId);
5308 return new ParceledListSlice<ApplicationInfo>(list);
5312 public List<ApplicationInfo> getPersistentApplications(int flags) {
5313 final ArrayList<ApplicationInfo> finalList = new ArrayList<ApplicationInfo>();
5316 synchronized (mPackages) {
5317 final Iterator<PackageParser.Package> i = mPackages.values().iterator();
5318 final int userId = UserHandle.getCallingUserId();
5319 while (i.hasNext()) {
5320 final PackageParser.Package p = i.next();
5321 if (p.applicationInfo != null
5322 && (p.applicationInfo.flags&ApplicationInfo.FLAG_PERSISTENT) != 0
5323 && (!mSafeMode || isSystemApp(p))) {
5324 PackageSetting ps = mSettings.mPackages.get(p.packageName);
5326 ApplicationInfo ai = PackageParser.generateApplicationInfo(p, flags,
5327 ps.readUserState(userId), userId);
5340 public ProviderInfo resolveContentProvider(String name, int flags, int userId) {
5341 if (!sUserManager.exists(userId)) return null;
5343 synchronized (mPackages) {
5344 final PackageParser.Provider provider = mProvidersByAuthority.get(name);
5345 PackageSetting ps = provider != null
5346 ? mSettings.mPackages.get(provider.owner.packageName)
5349 && mSettings.isEnabledLPr(provider.info, flags, userId)
5350 && (!mSafeMode || (provider.info.applicationInfo.flags
5351 &ApplicationInfo.FLAG_SYSTEM) != 0)
5352 ? PackageParser.generateProviderInfo(provider, flags,
5353 ps.readUserState(userId), userId)
5362 public void querySyncProviders(List<String> outNames, List<ProviderInfo> outInfo) {
5364 synchronized (mPackages) {
5365 final Iterator<Map.Entry<String, PackageParser.Provider>> i = mProvidersByAuthority
5366 .entrySet().iterator();
5367 final int userId = UserHandle.getCallingUserId();
5368 while (i.hasNext()) {
5369 Map.Entry<String, PackageParser.Provider> entry = i.next();
5370 PackageParser.Provider p = entry.getValue();
5371 PackageSetting ps = mSettings.mPackages.get(p.owner.packageName);
5373 if (ps != null && p.syncable
5374 && (!mSafeMode || (p.info.applicationInfo.flags
5375 &ApplicationInfo.FLAG_SYSTEM) != 0)) {
5376 ProviderInfo info = PackageParser.generateProviderInfo(p, 0,
5377 ps.readUserState(userId), userId);
5379 outNames.add(entry.getKey());
5388 public List<ProviderInfo> queryContentProviders(String processName,
5389 int uid, int flags) {
5390 ArrayList<ProviderInfo> finalList = null;
5392 synchronized (mPackages) {
5393 final Iterator<PackageParser.Provider> i = mProviders.mProviders.values().iterator();
5394 final int userId = processName != null ?
5395 UserHandle.getUserId(uid) : UserHandle.getCallingUserId();
5396 while (i.hasNext()) {
5397 final PackageParser.Provider p = i.next();
5398 PackageSetting ps = mSettings.mPackages.get(p.owner.packageName);
5399 if (ps != null && p.info.authority != null
5400 && (processName == null
5401 || (p.info.processName.equals(processName)
5402 && UserHandle.isSameApp(p.info.applicationInfo.uid, uid)))
5403 && mSettings.isEnabledLPr(p.info, flags, userId)
5405 || (p.info.applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM) != 0)) {
5406 if (finalList == null) {
5407 finalList = new ArrayList<ProviderInfo>(3);
5409 ProviderInfo info = PackageParser.generateProviderInfo(p, flags,
5410 ps.readUserState(userId), userId);
5412 finalList.add(info);
5418 if (finalList != null) {
5419 Collections.sort(finalList, mProviderInitOrderSorter);
5426 public InstrumentationInfo getInstrumentationInfo(ComponentName name,
5429 synchronized (mPackages) {
5430 final PackageParser.Instrumentation i = mInstrumentation.get(name);
5431 return PackageParser.generateInstrumentationInfo(i, flags);
5436 public List<InstrumentationInfo> queryInstrumentation(String targetPackage,
5438 ArrayList<InstrumentationInfo> finalList =
5439 new ArrayList<InstrumentationInfo>();
5442 synchronized (mPackages) {
5443 final Iterator<PackageParser.Instrumentation> i = mInstrumentation.values().iterator();
5444 while (i.hasNext()) {
5445 final PackageParser.Instrumentation p = i.next();
5446 if (targetPackage == null
5447 || targetPackage.equals(p.info.targetPackage)) {
5448 InstrumentationInfo ii = PackageParser.generateInstrumentationInfo(p,
5460 private void createIdmapsForPackageLI(PackageParser.Package pkg) {
5461 ArrayMap<String, PackageParser.Package> overlays = mOverlays.get(pkg.packageName);
5462 if (overlays == null) {
5463 Slog.w(TAG, "Unable to create idmap for " + pkg.packageName + ": no overlay packages");
5466 for (PackageParser.Package opkg : overlays.values()) {
5467 // Not much to do if idmap fails: we already logged the error
5468 // and we certainly don't want to abort installation of pkg simply
5469 // because an overlay didn't fit properly. For these reasons,
5470 // ignore the return value of createIdmapForPackagePairLI.
5471 createIdmapForPackagePairLI(pkg, opkg);
5475 private boolean createIdmapForPackagePairLI(PackageParser.Package pkg,
5476 PackageParser.Package opkg) {
5477 if (!opkg.mTrustedOverlay) {
5478 Slog.w(TAG, "Skipping target and overlay pair " + pkg.baseCodePath + " and " +
5479 opkg.baseCodePath + ": overlay not trusted");
5482 ArrayMap<String, PackageParser.Package> overlaySet = mOverlays.get(pkg.packageName);
5483 if (overlaySet == null) {
5484 Slog.e(TAG, "was about to create idmap for " + pkg.baseCodePath + " and " +
5485 opkg.baseCodePath + " but target package has no known overlays");
5488 final int sharedGid = UserHandle.getSharedAppGid(pkg.applicationInfo.uid);
5489 // TODO: generate idmap for split APKs
5490 if (mInstaller.idmap(pkg.baseCodePath, opkg.baseCodePath, sharedGid) != 0) {
5491 Slog.e(TAG, "Failed to generate idmap for " + pkg.baseCodePath + " and "
5492 + opkg.baseCodePath);
5495 PackageParser.Package[] overlayArray =
5496 overlaySet.values().toArray(new PackageParser.Package[0]);
5497 Comparator<PackageParser.Package> cmp = new Comparator<PackageParser.Package>() {
5498 public int compare(PackageParser.Package p1, PackageParser.Package p2) {
5499 return p1.mOverlayPriority - p2.mOverlayPriority;
5502 Arrays.sort(overlayArray, cmp);
5504 pkg.applicationInfo.resourceDirs = new String[overlayArray.length];
5506 for (PackageParser.Package p : overlayArray) {
5507 pkg.applicationInfo.resourceDirs[i++] = p.baseCodePath;
5512 private void scanDirLI(File dir, int parseFlags, int scanFlags, long currentTime) {
5513 final File[] files = dir.listFiles();
5514 if (ArrayUtils.isEmpty(files)) {
5515 Log.d(TAG, "No files in app dir " + dir);
5519 if (DEBUG_PACKAGE_SCANNING) {
5520 Log.d(TAG, "Scanning app dir " + dir + " scanFlags=" + scanFlags
5521 + " flags=0x" + Integer.toHexString(parseFlags));
5524 for (File file : files) {
5525 final boolean isPackage = (isApkFile(file) || file.isDirectory())
5526 && !PackageInstallerService.isStageName(file.getName());
5528 // Ignore entries which are not packages
5532 scanPackageLI(file, parseFlags | PackageParser.PARSE_MUST_BE_APK,
5533 scanFlags, currentTime, null);
5534 } catch (PackageManagerException e) {
5535 Slog.w(TAG, "Failed to parse " + file + ": " + e.getMessage());
5537 // Delete invalid userdata apps
5538 if ((parseFlags & PackageParser.PARSE_IS_SYSTEM) == 0 &&
5539 e.error == PackageManager.INSTALL_FAILED_INVALID_APK) {
5540 logCriticalInfo(Log.WARN, "Deleting invalid package at " + file);
5541 if (file.isDirectory()) {
5542 mInstaller.rmPackageDir(file.getAbsolutePath());
5551 private static File getSettingsProblemFile() {
5552 File dataDir = Environment.getDataDirectory();
5553 File systemDir = new File(dataDir, "system");
5554 File fname = new File(systemDir, "uiderrors.txt");
5558 static void reportSettingsProblem(int priority, String msg) {
5559 logCriticalInfo(priority, msg);
5562 static void logCriticalInfo(int priority, String msg) {
5563 Slog.println(priority, TAG, msg);
5564 EventLogTags.writePmCriticalInfo(msg);
5566 File fname = getSettingsProblemFile();
5567 FileOutputStream out = new FileOutputStream(fname, true);
5568 PrintWriter pw = new FastPrintWriter(out);
5569 SimpleDateFormat formatter = new SimpleDateFormat();
5570 String dateString = formatter.format(new Date(System.currentTimeMillis()));
5571 pw.println(dateString + ": " + msg);
5573 FileUtils.setPermissions(
5575 FileUtils.S_IRWXU|FileUtils.S_IRWXG|FileUtils.S_IROTH,
5577 } catch (java.io.IOException e) {
5581 private void collectCertificatesLI(PackageParser pp, PackageSetting ps,
5582 PackageParser.Package pkg, File srcFile, int parseFlags)
5583 throws PackageManagerException {
5585 && ps.codePath.equals(srcFile)
5586 && ps.timeStamp == srcFile.lastModified()
5587 && !isCompatSignatureUpdateNeeded(pkg)
5588 && !isRecoverSignatureUpdateNeeded(pkg)) {
5589 long mSigningKeySetId = ps.keySetData.getProperSigningKeySet();
5590 KeySetManagerService ksms = mSettings.mKeySetManagerService;
5591 ArraySet<PublicKey> signingKs;
5592 synchronized (mPackages) {
5593 signingKs = ksms.getPublicKeysFromKeySetLPr(mSigningKeySetId);
5595 if (ps.signatures.mSignatures != null
5596 && ps.signatures.mSignatures.length != 0
5597 && signingKs != null) {
5598 // Optimization: reuse the existing cached certificates
5599 // if the package appears to be unchanged.
5600 pkg.mSignatures = ps.signatures.mSignatures;
5601 pkg.mSigningKeys = signingKs;
5605 Slog.w(TAG, "PackageSetting for " + ps.name
5606 + " is missing signatures. Collecting certs again to recover them.");
5608 Log.i(TAG, srcFile.toString() + " changed; collecting certs");
5612 pp.collectCertificates(pkg, parseFlags);
5613 pp.collectManifestDigest(pkg);
5614 } catch (PackageParserException e) {
5615 throw PackageManagerException.from(e);
5620 * Scan a package and return the newly parsed package.
5621 * Returns null in case of errors and the error code is stored in mLastScanError
5623 private PackageParser.Package scanPackageLI(File scanFile, int parseFlags, int scanFlags,
5624 long currentTime, UserHandle user) throws PackageManagerException {
5625 if (DEBUG_INSTALL) Slog.d(TAG, "Parsing: " + scanFile);
5626 parseFlags |= mDefParseFlags;
5627 PackageParser pp = new PackageParser();
5628 pp.setSeparateProcesses(mSeparateProcesses);
5629 pp.setOnlyCoreApps(mOnlyCore);
5630 pp.setDisplayMetrics(mMetrics);
5632 if ((scanFlags & SCAN_TRUSTED_OVERLAY) != 0) {
5633 parseFlags |= PackageParser.PARSE_TRUSTED_OVERLAY;
5636 final PackageParser.Package pkg;
5638 pkg = pp.parsePackage(scanFile, parseFlags);
5639 } catch (PackageParserException e) {
5640 throw PackageManagerException.from(e);
5643 PackageSetting ps = null;
5644 PackageSetting updatedPkg;
5646 synchronized (mPackages) {
5647 // Look to see if we already know about this package.
5648 String oldName = mSettings.mRenamedPackages.get(pkg.packageName);
5649 if (pkg.mOriginalPackages != null && pkg.mOriginalPackages.contains(oldName)) {
5650 // This package has been renamed to its original name. Let's
5652 ps = mSettings.peekPackageLPr(oldName);
5654 // If there was no original package, see one for the real package name.
5656 ps = mSettings.peekPackageLPr(pkg.packageName);
5658 // Check to see if this package could be hiding/updating a system
5659 // package. Must look for it either under the original or real
5660 // package name depending on our state.
5661 updatedPkg = mSettings.getDisabledSystemPkgLPr(ps != null ? ps.name : pkg.packageName);
5662 if (DEBUG_INSTALL && updatedPkg != null) Slog.d(TAG, "updatedPkg = " + updatedPkg);
5664 boolean updatedPkgBetter = false;
5665 // First check if this is a system package that may involve an update
5666 if (updatedPkg != null && (parseFlags&PackageParser.PARSE_IS_SYSTEM) != 0) {
5667 // If new package is not located in "/system/priv-app" (e.g. due to an OTA),
5668 // it needs to drop FLAG_PRIVILEGED.
5669 if (locationIsPrivileged(scanFile)) {
5670 updatedPkg.pkgPrivateFlags |= ApplicationInfo.PRIVATE_FLAG_PRIVILEGED;
5672 updatedPkg.pkgPrivateFlags &= ~ApplicationInfo.PRIVATE_FLAG_PRIVILEGED;
5675 if (ps != null && !ps.codePath.equals(scanFile)) {
5676 // The path has changed from what was last scanned... check the
5677 // version of the new path against what we have stored to determine
5679 if (DEBUG_INSTALL) Slog.d(TAG, "Path changing from " + ps.codePath);
5680 if (pkg.mVersionCode <= ps.versionCode) {
5681 // The system package has been updated and the code path does not match
5682 // Ignore entry. Skip it.
5683 if (DEBUG_INSTALL) Slog.i(TAG, "Package " + ps.name + " at " + scanFile
5684 + " ignored: updated version " + ps.versionCode
5685 + " better than this " + pkg.mVersionCode);
5686 if (!updatedPkg.codePath.equals(scanFile)) {
5687 Slog.w(PackageManagerService.TAG, "Code path for hidden system pkg : "
5688 + ps.name + " changing from " + updatedPkg.codePathString
5689 + " to " + scanFile);
5690 updatedPkg.codePath = scanFile;
5691 updatedPkg.codePathString = scanFile.toString();
5692 updatedPkg.resourcePath = scanFile;
5693 updatedPkg.resourcePathString = scanFile.toString();
5695 updatedPkg.pkg = pkg;
5696 throw new PackageManagerException(INSTALL_FAILED_DUPLICATE_PACKAGE,
5697 "Package " + ps.name + " at " + scanFile
5698 + " ignored: updated version " + ps.versionCode
5699 + " better than this " + pkg.mVersionCode);
5701 // The current app on the system partition is better than
5702 // what we have updated to on the data partition; switch
5703 // back to the system partition version.
5704 // At this point, its safely assumed that package installation for
5705 // apps in system partition will go through. If not there won't be a working
5706 // version of the app
5708 synchronized (mPackages) {
5709 // Just remove the loaded entries from package lists.
5710 mPackages.remove(ps.name);
5713 logCriticalInfo(Log.WARN, "Package " + ps.name + " at " + scanFile
5714 + " reverting from " + ps.codePathString
5715 + ": new version " + pkg.mVersionCode
5716 + " better than installed " + ps.versionCode);
5718 InstallArgs args = createInstallArgsForExisting(packageFlagsToInstallFlags(ps),
5719 ps.codePathString, ps.resourcePathString, getAppDexInstructionSets(ps));
5720 synchronized (mInstallLock) {
5721 args.cleanUpResourcesLI();
5723 synchronized (mPackages) {
5724 mSettings.enableSystemPackageLPw(ps.name);
5726 updatedPkgBetter = true;
5731 if (updatedPkg != null) {
5732 // An updated system app will not have the PARSE_IS_SYSTEM flag set
5734 parseFlags |= PackageParser.PARSE_IS_SYSTEM;
5736 // An updated privileged app will not have the PARSE_IS_PRIVILEGED
5737 // flag set initially
5738 if ((updatedPkg.pkgPrivateFlags & ApplicationInfo.PRIVATE_FLAG_PRIVILEGED) != 0) {
5739 parseFlags |= PackageParser.PARSE_IS_PRIVILEGED;
5743 // Verify certificates against what was last scanned
5744 collectCertificatesLI(pp, ps, pkg, scanFile, parseFlags);
5747 * A new system app appeared, but we already had a non-system one of the
5748 * same name installed earlier.
5750 boolean shouldHideSystemApp = false;
5751 if (updatedPkg == null && ps != null
5752 && (parseFlags & PackageParser.PARSE_IS_SYSTEM_DIR) != 0 && !isSystemApp(ps)) {
5754 * Check to make sure the signatures match first. If they don't,
5755 * wipe the installed application and its data.
5757 if (compareSignatures(ps.signatures.mSignatures, pkg.mSignatures)
5758 != PackageManager.SIGNATURE_MATCH) {
5759 logCriticalInfo(Log.WARN, "Package " + ps.name + " appeared on system, but"
5760 + " signatures don't match existing userdata copy; removing");
5761 deletePackageLI(pkg.packageName, null, true, null, null, 0, null, false);
5765 * If the newly-added system app is an older version than the
5766 * already installed version, hide it. It will be scanned later
5767 * and re-added like an update.
5769 if (pkg.mVersionCode <= ps.versionCode) {
5770 shouldHideSystemApp = true;
5771 logCriticalInfo(Log.INFO, "Package " + ps.name + " appeared at " + scanFile
5772 + " but new version " + pkg.mVersionCode + " better than installed "
5773 + ps.versionCode + "; hiding system");
5776 * The newly found system app is a newer version that the
5777 * one previously installed. Simply remove the
5778 * already-installed application and replace it with our own
5779 * while keeping the application data.
5781 logCriticalInfo(Log.WARN, "Package " + ps.name + " at " + scanFile
5782 + " reverting from " + ps.codePathString + ": new version "
5783 + pkg.mVersionCode + " better than installed " + ps.versionCode);
5784 InstallArgs args = createInstallArgsForExisting(packageFlagsToInstallFlags(ps),
5785 ps.codePathString, ps.resourcePathString, getAppDexInstructionSets(ps));
5786 synchronized (mInstallLock) {
5787 args.cleanUpResourcesLI();
5793 // The apk is forward locked (not public) if its code and resources
5794 // are kept in different files. (except for app in either system or
5796 // TODO grab this value from PackageSettings
5797 if ((parseFlags & PackageParser.PARSE_IS_SYSTEM_DIR) == 0) {
5798 if (ps != null && !ps.codePath.equals(ps.resourcePath)) {
5799 parseFlags |= PackageParser.PARSE_FORWARD_LOCK;
5803 // TODO: extend to support forward-locked splits
5804 String resourcePath = null;
5805 String baseResourcePath = null;
5806 if ((parseFlags & PackageParser.PARSE_FORWARD_LOCK) != 0 && !updatedPkgBetter) {
5807 if (ps != null && ps.resourcePathString != null) {
5808 resourcePath = ps.resourcePathString;
5809 baseResourcePath = ps.resourcePathString;
5811 // Should not happen at all. Just log an error.
5812 Slog.e(TAG, "Resource path not set for pkg : " + pkg.packageName);
5815 resourcePath = pkg.codePath;
5816 baseResourcePath = pkg.baseCodePath;
5819 // Set application objects path explicitly.
5820 pkg.applicationInfo.volumeUuid = pkg.volumeUuid;
5821 pkg.applicationInfo.setCodePath(pkg.codePath);
5822 pkg.applicationInfo.setBaseCodePath(pkg.baseCodePath);
5823 pkg.applicationInfo.setSplitCodePaths(pkg.splitCodePaths);
5824 pkg.applicationInfo.setResourcePath(resourcePath);
5825 pkg.applicationInfo.setBaseResourcePath(baseResourcePath);
5826 pkg.applicationInfo.setSplitResourcePaths(pkg.splitCodePaths);
5828 // Note that we invoke the following method only if we are about to unpack an application
5829 PackageParser.Package scannedPkg = scanPackageLI(pkg, parseFlags, scanFlags
5830 | SCAN_UPDATE_SIGNATURE, currentTime, user);
5833 * If the system app should be overridden by a previously installed
5834 * data, hide the system app now and let the /data/app scan pick it up
5837 if (shouldHideSystemApp) {
5838 synchronized (mPackages) {
5840 * We have to grant systems permissions before we hide, because
5841 * grantPermissions will assume the package update is trying to
5842 * expand its permissions.
5844 grantPermissionsLPw(pkg, true, pkg.packageName);
5845 mSettings.disableSystemPackageLPw(pkg.packageName);
5852 private static String fixProcessName(String defProcessName,
5853 String processName, int uid) {
5854 if (processName == null) {
5855 return defProcessName;
5860 private void verifySignaturesLP(PackageSetting pkgSetting, PackageParser.Package pkg)
5861 throws PackageManagerException {
5862 if (pkgSetting.signatures.mSignatures != null) {
5863 // Already existing package. Make sure signatures match
5864 boolean match = compareSignatures(pkgSetting.signatures.mSignatures, pkg.mSignatures)
5865 == PackageManager.SIGNATURE_MATCH;
5867 match = compareSignaturesCompat(pkgSetting.signatures, pkg)
5868 == PackageManager.SIGNATURE_MATCH;
5871 match = compareSignaturesRecover(pkgSetting.signatures, pkg)
5872 == PackageManager.SIGNATURE_MATCH;
5875 throw new PackageManagerException(INSTALL_FAILED_UPDATE_INCOMPATIBLE, "Package "
5876 + pkg.packageName + " signatures do not match the "
5877 + "previously installed version; ignoring!");
5881 // Check for shared user signatures
5882 if (pkgSetting.sharedUser != null && pkgSetting.sharedUser.signatures.mSignatures != null) {
5883 // Already existing package. Make sure signatures match
5884 boolean match = compareSignatures(pkgSetting.sharedUser.signatures.mSignatures,
5885 pkg.mSignatures) == PackageManager.SIGNATURE_MATCH;
5887 match = compareSignaturesCompat(pkgSetting.sharedUser.signatures, pkg)
5888 == PackageManager.SIGNATURE_MATCH;
5891 match = compareSignaturesRecover(pkgSetting.sharedUser.signatures, pkg)
5892 == PackageManager.SIGNATURE_MATCH;
5895 throw new PackageManagerException(INSTALL_FAILED_SHARED_USER_INCOMPATIBLE,
5896 "Package " + pkg.packageName
5897 + " has no signatures that match those in shared user "
5898 + pkgSetting.sharedUser.name + "; ignoring!");
5904 * Enforces that only the system UID or root's UID can call a method exposed
5907 * @param message used as message if SecurityException is thrown
5908 * @throws SecurityException if the caller is not system or root
5910 private static final void enforceSystemOrRoot(String message) {
5911 final int uid = Binder.getCallingUid();
5912 if (uid != Process.SYSTEM_UID && uid != 0) {
5913 throw new SecurityException(message);
5918 public void performBootDexOpt() {
5919 enforceSystemOrRoot("Only the system can request dexopt be performed");
5921 // Before everything else, see whether we need to fstrim.
5923 IMountService ms = PackageHelper.getMountService();
5925 final boolean isUpgrade = isUpgrade();
5926 boolean doTrim = isUpgrade;
5928 Slog.w(TAG, "Running disk maintenance immediately due to system update");
5930 final long interval = android.provider.Settings.Global.getLong(
5931 mContext.getContentResolver(),
5932 android.provider.Settings.Global.FSTRIM_MANDATORY_INTERVAL,
5933 DEFAULT_MANDATORY_FSTRIM_INTERVAL);
5935 final long timeSinceLast = System.currentTimeMillis() - ms.lastMaintenance();
5936 if (timeSinceLast > interval) {
5938 Slog.w(TAG, "No disk maintenance in " + timeSinceLast
5939 + "; running immediately");
5944 if (!isFirstBoot()) {
5946 ActivityManagerNative.getDefault().showBootMessage(
5947 mContext.getResources().getString(
5948 R.string.android_upgrading_fstrim), true);
5949 } catch (RemoteException e) {
5952 ms.runMaintenance();
5955 Slog.e(TAG, "Mount service unavailable!");
5957 } catch (RemoteException e) {
5958 // Can't happen; MountService is local
5961 final ArraySet<PackageParser.Package> pkgs;
5962 synchronized (mPackages) {
5963 pkgs = mPackageDexOptimizer.clearDeferredDexOptPackages();
5967 // Sort apps by importance for dexopt ordering. Important apps are given more priority
5968 // in case the device runs out of space.
5969 ArrayList<PackageParser.Package> sortedPkgs = new ArrayList<PackageParser.Package>();
5970 // Give priority to core apps.
5971 for (Iterator<PackageParser.Package> it = pkgs.iterator(); it.hasNext();) {
5972 PackageParser.Package pkg = it.next();
5975 Log.i(TAG, "Adding core app " + sortedPkgs.size() + ": " + pkg.packageName);
5977 sortedPkgs.add(pkg);
5981 // Give priority to system apps that listen for pre boot complete.
5982 Intent intent = new Intent(Intent.ACTION_PRE_BOOT_COMPLETED);
5983 ArraySet<String> pkgNames = getPackageNamesForIntent(intent);
5984 for (Iterator<PackageParser.Package> it = pkgs.iterator(); it.hasNext();) {
5985 PackageParser.Package pkg = it.next();
5986 if (pkgNames.contains(pkg.packageName)) {
5988 Log.i(TAG, "Adding pre boot system app " + sortedPkgs.size() + ": " + pkg.packageName);
5990 sortedPkgs.add(pkg);
5994 // Give priority to system apps.
5995 for (Iterator<PackageParser.Package> it = pkgs.iterator(); it.hasNext();) {
5996 PackageParser.Package pkg = it.next();
5997 if (isSystemApp(pkg) && !pkg.isUpdatedSystemApp()) {
5999 Log.i(TAG, "Adding system app " + sortedPkgs.size() + ": " + pkg.packageName);
6001 sortedPkgs.add(pkg);
6005 // Give priority to updated system apps.
6006 for (Iterator<PackageParser.Package> it = pkgs.iterator(); it.hasNext();) {
6007 PackageParser.Package pkg = it.next();
6008 if (pkg.isUpdatedSystemApp()) {
6010 Log.i(TAG, "Adding updated system app " + sortedPkgs.size() + ": " + pkg.packageName);
6012 sortedPkgs.add(pkg);
6016 // Give priority to apps that listen for boot complete.
6017 intent = new Intent(Intent.ACTION_BOOT_COMPLETED);
6018 pkgNames = getPackageNamesForIntent(intent);
6019 for (Iterator<PackageParser.Package> it = pkgs.iterator(); it.hasNext();) {
6020 PackageParser.Package pkg = it.next();
6021 if (pkgNames.contains(pkg.packageName)) {
6023 Log.i(TAG, "Adding boot app " + sortedPkgs.size() + ": " + pkg.packageName);
6025 sortedPkgs.add(pkg);
6029 // Filter out packages that aren't recently used.
6030 filterRecentlyUsedApps(pkgs);
6031 // Add all remaining apps.
6032 for (PackageParser.Package pkg : pkgs) {
6034 Log.i(TAG, "Adding app " + sortedPkgs.size() + ": " + pkg.packageName);
6036 sortedPkgs.add(pkg);
6039 // If we want to be lazy, filter everything that wasn't recently used.
6041 filterRecentlyUsedApps(sortedPkgs);
6045 int total = sortedPkgs.size();
6046 File dataDir = Environment.getDataDirectory();
6047 long lowThreshold = StorageManager.from(mContext).getStorageLowBytes(dataDir);
6048 if (lowThreshold == 0) {
6049 throw new IllegalStateException("Invalid low memory threshold");
6051 for (PackageParser.Package pkg : sortedPkgs) {
6052 long usableSpace = dataDir.getUsableSpace();
6053 if (usableSpace < lowThreshold) {
6054 Log.w(TAG, "Not running dexopt on remaining apps due to low memory: " + usableSpace);
6057 performBootDexOpt(pkg, ++i, total);
6062 private void filterRecentlyUsedApps(Collection<PackageParser.Package> pkgs) {
6063 // Filter out packages that aren't recently used.
6065 // The exception is first boot of a non-eng device (aka !mLazyDexOpt), which
6066 // should do a full dexopt.
6067 if (mLazyDexOpt || (!isFirstBoot() && mPackageUsage.isHistoricalPackageUsageAvailable())) {
6068 int total = pkgs.size();
6070 long now = System.currentTimeMillis();
6071 for (Iterator<PackageParser.Package> i = pkgs.iterator(); i.hasNext();) {
6072 PackageParser.Package pkg = i.next();
6073 long then = pkg.mLastPackageUsageTimeInMills;
6074 if (then + mDexOptLRUThresholdInMills < now) {
6076 Log.i(TAG, "Skipping dexopt of " + pkg.packageName + " last resumed: " +
6077 ((then == 0) ? "never" : new Date(then)));
6084 Log.i(TAG, "Skipped optimizing " + skipped + " of " + total);
6089 private ArraySet<String> getPackageNamesForIntent(Intent intent) {
6090 List<ResolveInfo> ris = null;
6092 ris = AppGlobals.getPackageManager().queryIntentReceivers(
6093 intent, null, 0, UserHandle.USER_OWNER);
6094 } catch (RemoteException e) {
6096 ArraySet<String> pkgNames = new ArraySet<String>();
6098 for (ResolveInfo ri : ris) {
6099 pkgNames.add(ri.activityInfo.packageName);
6105 private void performBootDexOpt(PackageParser.Package pkg, int curr, int total) {
6107 Log.i(TAG, "Optimizing app " + curr + " of " + total + ": " + pkg.packageName);
6109 if (!isFirstBoot()) {
6111 ActivityManagerNative.getDefault().showBootMessage(
6112 mContext.getResources().getString(R.string.android_upgrading_apk,
6113 curr, total), true);
6114 } catch (RemoteException e) {
6117 PackageParser.Package p = pkg;
6118 synchronized (mInstallLock) {
6119 mPackageDexOptimizer.performDexOpt(p, null /* instruction sets */,
6120 false /* force dex */, false /* defer */, true /* include dependencies */);
6125 public boolean performDexOptIfNeeded(String packageName, String instructionSet) {
6126 return performDexOpt(packageName, instructionSet, false);
6129 public boolean performDexOpt(String packageName, String instructionSet, boolean backgroundDexopt) {
6130 boolean dexopt = mLazyDexOpt || backgroundDexopt;
6131 boolean updateUsage = !backgroundDexopt; // Don't update usage if this is just a backgroundDexopt
6132 if (!dexopt && !updateUsage) {
6133 // We aren't going to dexopt or update usage, so bail early.
6136 PackageParser.Package p;
6137 final String targetInstructionSet;
6138 synchronized (mPackages) {
6139 p = mPackages.get(packageName);
6144 p.mLastPackageUsageTimeInMills = System.currentTimeMillis();
6146 mPackageUsage.write(false);
6148 // We aren't going to dexopt, so bail early.
6152 targetInstructionSet = instructionSet != null ? instructionSet :
6153 getPrimaryInstructionSet(p.applicationInfo);
6154 if (p.mDexOptPerformed.contains(targetInstructionSet)) {
6159 synchronized (mInstallLock) {
6160 final String[] instructionSets = new String[] { targetInstructionSet };
6161 int result = mPackageDexOptimizer.performDexOpt(p, instructionSets,
6162 false /* forceDex */, false /* defer */, true /* inclDependencies */);
6163 return result == PackageDexOptimizer.DEX_OPT_PERFORMED;
6167 public ArraySet<String> getPackagesThatNeedDexOpt() {
6168 ArraySet<String> pkgs = null;
6169 synchronized (mPackages) {
6170 for (PackageParser.Package p : mPackages.values()) {
6172 Log.i(TAG, p.packageName + " mDexOptPerformed=" + p.mDexOptPerformed.toArray());
6174 if (!p.mDexOptPerformed.isEmpty()) {
6178 pkgs = new ArraySet<String>();
6180 pkgs.add(p.packageName);
6186 public void shutdown() {
6187 mPackageUsage.write(true);
6191 public void forceDexOpt(String packageName) {
6192 enforceSystemOrRoot("forceDexOpt");
6194 PackageParser.Package pkg;
6195 synchronized (mPackages) {
6196 pkg = mPackages.get(packageName);
6198 throw new IllegalArgumentException("Missing package: " + packageName);
6202 synchronized (mInstallLock) {
6203 final String[] instructionSets = new String[] {
6204 getPrimaryInstructionSet(pkg.applicationInfo) };
6205 final int res = mPackageDexOptimizer.performDexOpt(pkg, instructionSets,
6206 true /*forceDex*/, false /* defer */, true /* inclDependencies */);
6207 if (res != PackageDexOptimizer.DEX_OPT_PERFORMED) {
6208 throw new IllegalStateException("Failed to dexopt: " + res);
6213 private boolean verifyPackageUpdateLPr(PackageSetting oldPkg, PackageParser.Package newPkg) {
6214 if ((oldPkg.pkgFlags&ApplicationInfo.FLAG_SYSTEM) == 0) {
6215 Slog.w(TAG, "Unable to update from " + oldPkg.name
6216 + " to " + newPkg.packageName
6217 + ": old package not in system partition");
6219 } else if (mPackages.get(oldPkg.name) != null) {
6220 Slog.w(TAG, "Unable to update from " + oldPkg.name
6221 + " to " + newPkg.packageName
6222 + ": old package still exists");
6228 private int createDataDirsLI(String volumeUuid, String packageName, int uid, String seinfo) {
6229 int[] users = sUserManager.getUserIds();
6230 int res = mInstaller.install(volumeUuid, packageName, uid, uid, seinfo);
6234 for (int user : users) {
6236 res = mInstaller.createUserData(volumeUuid, packageName,
6237 UserHandle.getUid(user, uid), user, seinfo);
6246 private int removeDataDirsLI(String volumeUuid, String packageName) {
6247 int[] users = sUserManager.getUserIds();
6249 for (int user : users) {
6250 int resInner = mInstaller.remove(volumeUuid, packageName, user);
6259 private int deleteCodeCacheDirsLI(String volumeUuid, String packageName) {
6260 int[] users = sUserManager.getUserIds();
6262 for (int user : users) {
6263 int resInner = mInstaller.deleteCodeCacheFiles(volumeUuid, packageName, user);
6271 private void addSharedLibraryLPw(ArraySet<String> usesLibraryFiles, SharedLibraryEntry file,
6272 PackageParser.Package changingLib) {
6273 if (file.path != null) {
6274 usesLibraryFiles.add(file.path);
6277 PackageParser.Package p = mPackages.get(file.apk);
6278 if (changingLib != null && changingLib.packageName.equals(file.apk)) {
6279 // If we are doing this while in the middle of updating a library apk,
6280 // then we need to make sure to use that new apk for determining the
6281 // dependencies here. (We haven't yet finished committing the new apk
6282 // to the package manager state.)
6283 if (p == null || p.packageName.equals(changingLib.packageName)) {
6288 usesLibraryFiles.addAll(p.getAllCodePaths());
6292 private void updateSharedLibrariesLPw(PackageParser.Package pkg,
6293 PackageParser.Package changingLib) throws PackageManagerException {
6294 if (pkg.usesLibraries != null || pkg.usesOptionalLibraries != null) {
6295 final ArraySet<String> usesLibraryFiles = new ArraySet<>();
6296 int N = pkg.usesLibraries != null ? pkg.usesLibraries.size() : 0;
6297 for (int i=0; i<N; i++) {
6298 final SharedLibraryEntry file = mSharedLibraries.get(pkg.usesLibraries.get(i));
6300 throw new PackageManagerException(INSTALL_FAILED_MISSING_SHARED_LIBRARY,
6301 "Package " + pkg.packageName + " requires unavailable shared library "
6302 + pkg.usesLibraries.get(i) + "; failing!");
6304 addSharedLibraryLPw(usesLibraryFiles, file, changingLib);
6306 N = pkg.usesOptionalLibraries != null ? pkg.usesOptionalLibraries.size() : 0;
6307 for (int i=0; i<N; i++) {
6308 final SharedLibraryEntry file = mSharedLibraries.get(pkg.usesOptionalLibraries.get(i));
6310 Slog.w(TAG, "Package " + pkg.packageName
6311 + " desires unavailable shared library "
6312 + pkg.usesOptionalLibraries.get(i) + "; ignoring!");
6314 addSharedLibraryLPw(usesLibraryFiles, file, changingLib);
6317 N = usesLibraryFiles.size();
6319 pkg.usesLibraryFiles = usesLibraryFiles.toArray(new String[N]);
6321 pkg.usesLibraryFiles = null;
6326 private static boolean hasString(List<String> list, List<String> which) {
6330 for (int i=list.size()-1; i>=0; i--) {
6331 for (int j=which.size()-1; j>=0; j--) {
6332 if (which.get(j).equals(list.get(i))) {
6340 private void updateAllSharedLibrariesLPw() {
6341 for (PackageParser.Package pkg : mPackages.values()) {
6343 updateSharedLibrariesLPw(pkg, null);
6344 } catch (PackageManagerException e) {
6345 Slog.e(TAG, "updateAllSharedLibrariesLPw failed: " + e.getMessage());
6350 private ArrayList<PackageParser.Package> updateAllSharedLibrariesLPw(
6351 PackageParser.Package changingPkg) {
6352 ArrayList<PackageParser.Package> res = null;
6353 for (PackageParser.Package pkg : mPackages.values()) {
6354 if (hasString(pkg.usesLibraries, changingPkg.libraryNames)
6355 || hasString(pkg.usesOptionalLibraries, changingPkg.libraryNames)) {
6357 res = new ArrayList<PackageParser.Package>();
6361 updateSharedLibrariesLPw(pkg, changingPkg);
6362 } catch (PackageManagerException e) {
6363 Slog.e(TAG, "updateAllSharedLibrariesLPw failed: " + e.getMessage());
6371 * Derive the value of the {@code cpuAbiOverride} based on the provided
6372 * value and an optional stored value from the package settings.
6374 private static String deriveAbiOverride(String abiOverride, PackageSetting settings) {
6375 String cpuAbiOverride = null;
6377 if (NativeLibraryHelper.CLEAR_ABI_OVERRIDE.equals(abiOverride)) {
6378 cpuAbiOverride = null;
6379 } else if (abiOverride != null) {
6380 cpuAbiOverride = abiOverride;
6381 } else if (settings != null) {
6382 cpuAbiOverride = settings.cpuAbiOverrideString;
6385 return cpuAbiOverride;
6388 private PackageParser.Package scanPackageLI(PackageParser.Package pkg, int parseFlags,
6389 int scanFlags, long currentTime, UserHandle user) throws PackageManagerException {
6390 boolean success = false;
6392 final PackageParser.Package res = scanPackageDirtyLI(pkg, parseFlags, scanFlags,
6397 if (!success && (scanFlags & SCAN_DELETE_DATA_ON_FAILURES) != 0) {
6398 removeDataDirsLI(pkg.volumeUuid, pkg.packageName);
6403 private PackageParser.Package scanPackageDirtyLI(PackageParser.Package pkg, int parseFlags,
6404 int scanFlags, long currentTime, UserHandle user) throws PackageManagerException {
6405 final File scanFile = new File(pkg.codePath);
6406 if (pkg.applicationInfo.getCodePath() == null ||
6407 pkg.applicationInfo.getResourcePath() == null) {
6408 // Bail out. The resource and code paths haven't been set.
6409 throw new PackageManagerException(INSTALL_FAILED_INVALID_APK,
6410 "Code and resource paths haven't been set correctly");
6413 if ((parseFlags&PackageParser.PARSE_IS_SYSTEM) != 0) {
6414 pkg.applicationInfo.flags |= ApplicationInfo.FLAG_SYSTEM;
6416 // Only allow system apps to be flagged as core apps.
6417 pkg.coreApp = false;
6420 if ((parseFlags&PackageParser.PARSE_IS_PRIVILEGED) != 0) {
6421 pkg.applicationInfo.privateFlags |= ApplicationInfo.PRIVATE_FLAG_PRIVILEGED;
6424 if (mCustomResolverComponentName != null &&
6425 mCustomResolverComponentName.getPackageName().equals(pkg.packageName)) {
6426 setUpCustomResolverActivity(pkg);
6429 if (pkg.packageName.equals("android")) {
6430 synchronized (mPackages) {
6431 if (mAndroidApplication != null) {
6432 Slog.w(TAG, "*************************************************");
6433 Slog.w(TAG, "Core android package being redefined. Skipping.");
6434 Slog.w(TAG, " file=" + scanFile);
6435 Slog.w(TAG, "*************************************************");
6436 throw new PackageManagerException(INSTALL_FAILED_DUPLICATE_PACKAGE,
6437 "Core android package being redefined. Skipping.");
6440 // Set up information for our fall-back user intent resolution activity.
6441 mPlatformPackage = pkg;
6442 pkg.mVersionCode = mSdkVersion;
6443 mAndroidApplication = pkg.applicationInfo;
6445 if (!mResolverReplaced) {
6446 mResolveActivity.applicationInfo = mAndroidApplication;
6447 mResolveActivity.name = ResolverActivity.class.getName();
6448 mResolveActivity.packageName = mAndroidApplication.packageName;
6449 mResolveActivity.processName = "system:ui";
6450 mResolveActivity.launchMode = ActivityInfo.LAUNCH_MULTIPLE;
6451 mResolveActivity.documentLaunchMode = ActivityInfo.DOCUMENT_LAUNCH_NEVER;
6452 mResolveActivity.flags = ActivityInfo.FLAG_EXCLUDE_FROM_RECENTS;
6453 mResolveActivity.theme = R.style.Theme_Holo_Dialog_Alert;
6454 mResolveActivity.exported = true;
6455 mResolveActivity.enabled = true;
6456 mResolveInfo.activityInfo = mResolveActivity;
6457 mResolveInfo.priority = 0;
6458 mResolveInfo.preferredOrder = 0;
6459 mResolveInfo.match = 0;
6460 mResolveComponentName = new ComponentName(
6461 mAndroidApplication.packageName, mResolveActivity.name);
6466 if (DEBUG_PACKAGE_SCANNING) {
6467 if ((parseFlags & PackageParser.PARSE_CHATTY) != 0)
6468 Log.d(TAG, "Scanning package " + pkg.packageName);
6471 if (mPackages.containsKey(pkg.packageName)
6472 || mSharedLibraries.containsKey(pkg.packageName)) {
6473 throw new PackageManagerException(INSTALL_FAILED_DUPLICATE_PACKAGE,
6474 "Application package " + pkg.packageName
6475 + " already installed. Skipping duplicate.");
6478 // If we're only installing presumed-existing packages, require that the
6479 // scanned APK is both already known and at the path previously established
6480 // for it. Previously unknown packages we pick up normally, but if we have an
6481 // a priori expectation about this package's install presence, enforce it.
6482 // With a singular exception for new system packages. When an OTA contains
6483 // a new system package, we allow the codepath to change from a system location
6484 // to the user-installed location. If we don't allow this change, any newer,
6485 // user-installed version of the application will be ignored.
6486 if ((scanFlags & SCAN_REQUIRE_KNOWN) != 0) {
6487 if (mExpectingBetter.containsKey(pkg.packageName)) {
6488 logCriticalInfo(Log.WARN,
6489 "Relax SCAN_REQUIRE_KNOWN requirement for package " + pkg.packageName);
6491 PackageSetting known = mSettings.peekPackageLPr(pkg.packageName);
6492 if (known != null) {
6493 if (DEBUG_PACKAGE_SCANNING) {
6494 Log.d(TAG, "Examining " + pkg.codePath
6495 + " and requiring known paths " + known.codePathString
6496 + " & " + known.resourcePathString);
6498 if (!pkg.applicationInfo.getCodePath().equals(known.codePathString)
6499 || !pkg.applicationInfo.getResourcePath().equals(known.resourcePathString)) {
6500 throw new PackageManagerException(INSTALL_FAILED_PACKAGE_CHANGED,
6501 "Application package " + pkg.packageName
6502 + " found at " + pkg.applicationInfo.getCodePath()
6503 + " but expected at " + known.codePathString + "; ignoring.");
6509 // Initialize package source and resource directories
6510 File destCodeFile = new File(pkg.applicationInfo.getCodePath());
6511 File destResourceFile = new File(pkg.applicationInfo.getResourcePath());
6513 SharedUserSetting suid = null;
6514 PackageSetting pkgSetting = null;
6516 if (!isSystemApp(pkg)) {
6517 // Only system apps can use these features.
6518 pkg.mOriginalPackages = null;
6519 pkg.mRealPackage = null;
6520 pkg.mAdoptPermissions = null;
6524 synchronized (mPackages) {
6525 if (pkg.mSharedUserId != null) {
6526 suid = mSettings.getSharedUserLPw(pkg.mSharedUserId, 0, 0, true);
6528 throw new PackageManagerException(INSTALL_FAILED_INSUFFICIENT_STORAGE,
6529 "Creating application package " + pkg.packageName
6530 + " for shared user failed");
6532 if (DEBUG_PACKAGE_SCANNING) {
6533 if ((parseFlags & PackageParser.PARSE_CHATTY) != 0)
6534 Log.d(TAG, "Shared UserID " + pkg.mSharedUserId + " (uid=" + suid.userId
6535 + "): packages=" + suid.packages);
6539 // Check if we are renaming from an original package name.
6540 PackageSetting origPackage = null;
6541 String realName = null;
6542 if (pkg.mOriginalPackages != null) {
6543 // This package may need to be renamed to a previously
6544 // installed name. Let's check on that...
6545 final String renamed = mSettings.mRenamedPackages.get(pkg.mRealPackage);
6546 if (pkg.mOriginalPackages.contains(renamed)) {
6547 // This package had originally been installed as the
6548 // original name, and we have already taken care of
6549 // transitioning to the new one. Just update the new
6550 // one to continue using the old name.
6551 realName = pkg.mRealPackage;
6552 if (!pkg.packageName.equals(renamed)) {
6553 // Callers into this function may have already taken
6554 // care of renaming the package; only do it here if
6555 // it is not already done.
6556 pkg.setPackageName(renamed);
6560 for (int i=pkg.mOriginalPackages.size()-1; i>=0; i--) {
6561 if ((origPackage = mSettings.peekPackageLPr(
6562 pkg.mOriginalPackages.get(i))) != null) {
6563 // We do have the package already installed under its
6564 // original name... should we use it?
6565 if (!verifyPackageUpdateLPr(origPackage, pkg)) {
6566 // New package is not compatible with original.
6569 } else if (origPackage.sharedUser != null) {
6570 // Make sure uid is compatible between packages.
6571 if (!origPackage.sharedUser.name.equals(pkg.mSharedUserId)) {
6572 Slog.w(TAG, "Unable to migrate data from " + origPackage.name
6573 + " to " + pkg.packageName + ": old uid "
6574 + origPackage.sharedUser.name
6575 + " differs from " + pkg.mSharedUserId);
6580 if (DEBUG_UPGRADE) Log.v(TAG, "Renaming new package "
6581 + pkg.packageName + " to old name " + origPackage.name);
6589 if (mTransferedPackages.contains(pkg.packageName)) {
6590 Slog.w(TAG, "Package " + pkg.packageName
6591 + " was transferred to another, but its .apk remains");
6594 // Just create the setting, don't add it yet. For already existing packages
6595 // the PkgSetting exists already and doesn't have to be created.
6596 pkgSetting = mSettings.getPackageLPw(pkg, origPackage, realName, suid, destCodeFile,
6597 destResourceFile, pkg.applicationInfo.nativeLibraryRootDir,
6598 pkg.applicationInfo.primaryCpuAbi,
6599 pkg.applicationInfo.secondaryCpuAbi,
6600 pkg.applicationInfo.flags, pkg.applicationInfo.privateFlags,
6602 if (pkgSetting == null) {
6603 throw new PackageManagerException(INSTALL_FAILED_INSUFFICIENT_STORAGE,
6604 "Creating application package " + pkg.packageName + " failed");
6607 if (pkgSetting.origPackage != null) {
6608 // If we are first transitioning from an original package,
6609 // fix up the new package's name now. We need to do this after
6610 // looking up the package under its new name, so getPackageLP
6611 // can take care of fiddling things correctly.
6612 pkg.setPackageName(origPackage.name);
6614 // File a report about this.
6615 String msg = "New package " + pkgSetting.realName
6616 + " renamed to replace old package " + pkgSetting.name;
6617 reportSettingsProblem(Log.WARN, msg);
6619 // Make a note of it.
6620 mTransferedPackages.add(origPackage.name);
6622 // No longer need to retain this.
6623 pkgSetting.origPackage = null;
6626 if (realName != null) {
6627 // Make a note of it.
6628 mTransferedPackages.add(pkg.packageName);
6631 if (mSettings.isDisabledSystemPackageLPr(pkg.packageName)) {
6632 pkg.applicationInfo.flags |= ApplicationInfo.FLAG_UPDATED_SYSTEM_APP;
6635 if ((parseFlags&PackageParser.PARSE_IS_SYSTEM_DIR) == 0) {
6636 // Check all shared libraries and map to their actual file path.
6637 // We only do this here for apps not on a system dir, because those
6638 // are the only ones that can fail an install due to this. We
6639 // will take care of the system apps by updating all of their
6640 // library paths after the scan is done.
6641 updateSharedLibrariesLPw(pkg, null);
6644 if (mFoundPolicyFile) {
6645 SELinuxMMAC.assignSeinfoValue(pkg);
6648 pkg.applicationInfo.uid = pkgSetting.appId;
6649 pkg.mExtras = pkgSetting;
6650 if (shouldCheckUpgradeKeySetLP(pkgSetting, scanFlags)) {
6651 if (checkUpgradeKeySetLP(pkgSetting, pkg)) {
6652 // We just determined the app is signed correctly, so bring
6653 // over the latest parsed certs.
6654 pkgSetting.signatures.mSignatures = pkg.mSignatures;
6656 if ((parseFlags & PackageParser.PARSE_IS_SYSTEM_DIR) == 0) {
6657 throw new PackageManagerException(INSTALL_FAILED_UPDATE_INCOMPATIBLE,
6658 "Package " + pkg.packageName + " upgrade keys do not match the "
6659 + "previously installed version");
6661 pkgSetting.signatures.mSignatures = pkg.mSignatures;
6662 String msg = "System package " + pkg.packageName
6663 + " signature changed; retaining data.";
6664 reportSettingsProblem(Log.WARN, msg);
6669 verifySignaturesLP(pkgSetting, pkg);
6670 // We just determined the app is signed correctly, so bring
6671 // over the latest parsed certs.
6672 pkgSetting.signatures.mSignatures = pkg.mSignatures;
6673 } catch (PackageManagerException e) {
6674 if ((parseFlags & PackageParser.PARSE_IS_SYSTEM_DIR) == 0) {
6677 // The signature has changed, but this package is in the system
6678 // image... let's recover!
6679 pkgSetting.signatures.mSignatures = pkg.mSignatures;
6680 // However... if this package is part of a shared user, but it
6681 // doesn't match the signature of the shared user, let's fail.
6682 // What this means is that you can't change the signatures
6683 // associated with an overall shared user, which doesn't seem all
6684 // that unreasonable.
6685 if (pkgSetting.sharedUser != null) {
6686 if (compareSignatures(pkgSetting.sharedUser.signatures.mSignatures,
6687 pkg.mSignatures) != PackageManager.SIGNATURE_MATCH) {
6688 throw new PackageManagerException(
6689 INSTALL_PARSE_FAILED_INCONSISTENT_CERTIFICATES,
6690 "Signature mismatch for shared user : "
6691 + pkgSetting.sharedUser);
6694 // File a report about this.
6695 String msg = "System package " + pkg.packageName
6696 + " signature changed; retaining data.";
6697 reportSettingsProblem(Log.WARN, msg);
6700 // Verify that this new package doesn't have any content providers
6701 // that conflict with existing packages. Only do this if the
6702 // package isn't already installed, since we don't want to break
6703 // things that are installed.
6704 if ((scanFlags & SCAN_NEW_INSTALL) != 0) {
6705 final int N = pkg.providers.size();
6707 for (i=0; i<N; i++) {
6708 PackageParser.Provider p = pkg.providers.get(i);
6709 if (p.info.authority != null) {
6710 String names[] = p.info.authority.split(";");
6711 for (int j = 0; j < names.length; j++) {
6712 if (mProvidersByAuthority.containsKey(names[j])) {
6713 PackageParser.Provider other = mProvidersByAuthority.get(names[j]);
6714 final String otherPackageName =
6715 ((other != null && other.getComponentName() != null) ?
6716 other.getComponentName().getPackageName() : "?");
6717 throw new PackageManagerException(
6718 INSTALL_FAILED_CONFLICTING_PROVIDER,
6719 "Can't install because provider name " + names[j]
6720 + " (in package " + pkg.applicationInfo.packageName
6721 + ") is already used by " + otherPackageName);
6728 if (pkg.mAdoptPermissions != null) {
6729 // This package wants to adopt ownership of permissions from
6731 for (int i = pkg.mAdoptPermissions.size() - 1; i >= 0; i--) {
6732 final String origName = pkg.mAdoptPermissions.get(i);
6733 final PackageSetting orig = mSettings.peekPackageLPr(origName);
6735 if (verifyPackageUpdateLPr(orig, pkg)) {
6736 Slog.i(TAG, "Adopting permissions from " + origName + " to "
6738 mSettings.transferPermissionsLPw(origName, pkg.packageName);
6745 final String pkgName = pkg.packageName;
6747 final long scanFileTime = scanFile.lastModified();
6748 final boolean forceDex = (scanFlags & SCAN_FORCE_DEX) != 0;
6749 pkg.applicationInfo.processName = fixProcessName(
6750 pkg.applicationInfo.packageName,
6751 pkg.applicationInfo.processName,
6752 pkg.applicationInfo.uid);
6755 if (mPlatformPackage == pkg) {
6756 // The system package is special.
6757 dataPath = new File(Environment.getDataDirectory(), "system");
6759 pkg.applicationInfo.dataDir = dataPath.getPath();
6762 // This is a normal package, need to make its data directory.
6763 dataPath = Environment.getDataUserPackageDirectory(pkg.volumeUuid,
6764 UserHandle.USER_OWNER, pkg.packageName);
6766 boolean uidError = false;
6767 if (dataPath.exists()) {
6770 StructStat stat = Os.stat(dataPath.getPath());
6771 currentUid = stat.st_uid;
6772 } catch (ErrnoException e) {
6773 Slog.e(TAG, "Couldn't stat path " + dataPath.getPath(), e);
6776 // If we have mismatched owners for the data path, we have a problem.
6777 if (currentUid != pkg.applicationInfo.uid) {
6778 boolean recovered = false;
6779 if (currentUid == 0) {
6780 // The directory somehow became owned by root. Wow.
6781 // This is probably because the system was stopped while
6782 // installd was in the middle of messing with its libs
6783 // directory. Ask installd to fix that.
6784 int ret = mInstaller.fixUid(pkg.volumeUuid, pkgName,
6785 pkg.applicationInfo.uid, pkg.applicationInfo.uid);
6788 String msg = "Package " + pkg.packageName
6789 + " unexpectedly changed to uid 0; recovered to " +
6790 + pkg.applicationInfo.uid;
6791 reportSettingsProblem(Log.WARN, msg);
6794 if (!recovered && ((parseFlags&PackageParser.PARSE_IS_SYSTEM) != 0
6795 || (scanFlags&SCAN_BOOTING) != 0)) {
6796 // If this is a system app, we can at least delete its
6797 // current data so the application will still work.
6798 int ret = removeDataDirsLI(pkg.volumeUuid, pkgName);
6800 // TODO: Kill the processes first
6802 String prefix = (parseFlags&PackageParser.PARSE_IS_SYSTEM) != 0
6803 ? "System package " : "Third party package ";
6804 String msg = prefix + pkg.packageName
6805 + " has changed from uid: "
6806 + currentUid + " to "
6807 + pkg.applicationInfo.uid + "; old data erased";
6808 reportSettingsProblem(Log.WARN, msg);
6811 // And now re-install the app.
6812 ret = createDataDirsLI(pkg.volumeUuid, pkgName, pkg.applicationInfo.uid,
6813 pkg.applicationInfo.seinfo);
6815 // Ack should not happen!
6816 msg = prefix + pkg.packageName
6817 + " could not have data directory re-created after delete.";
6818 reportSettingsProblem(Log.WARN, msg);
6819 throw new PackageManagerException(
6820 INSTALL_FAILED_INSUFFICIENT_STORAGE, msg);
6824 mHasSystemUidErrors = true;
6826 } else if (!recovered) {
6827 // If we allow this install to proceed, we will be broken.
6829 throw new PackageManagerException(INSTALL_FAILED_UID_CHANGED,
6833 pkg.applicationInfo.dataDir = "/mismatched_uid/settings_"
6834 + pkg.applicationInfo.uid + "/fs_"
6836 pkg.applicationInfo.nativeLibraryDir = pkg.applicationInfo.dataDir;
6837 pkg.applicationInfo.nativeLibraryRootDir = pkg.applicationInfo.dataDir;
6838 String msg = "Package " + pkg.packageName
6839 + " has mismatched uid: "
6840 + currentUid + " on disk, "
6841 + pkg.applicationInfo.uid + " in settings";
6843 synchronized (mPackages) {
6844 mSettings.mReadMessages.append(msg);
6845 mSettings.mReadMessages.append('\n');
6847 if (!pkgSetting.uidError) {
6848 reportSettingsProblem(Log.ERROR, msg);
6853 pkg.applicationInfo.dataDir = dataPath.getPath();
6854 if (mShouldRestoreconData) {
6855 Slog.i(TAG, "SELinux relabeling of " + pkg.packageName + " issued.");
6856 mInstaller.restoreconData(pkg.volumeUuid, pkg.packageName,
6857 pkg.applicationInfo.seinfo, pkg.applicationInfo.uid);
6860 if (DEBUG_PACKAGE_SCANNING) {
6861 if ((parseFlags & PackageParser.PARSE_CHATTY) != 0)
6862 Log.v(TAG, "Want this data dir: " + dataPath);
6864 //invoke installer to do the actual installation
6865 int ret = createDataDirsLI(pkg.volumeUuid, pkgName, pkg.applicationInfo.uid,
6866 pkg.applicationInfo.seinfo);
6868 // Error from installer
6869 throw new PackageManagerException(INSTALL_FAILED_INSUFFICIENT_STORAGE,
6870 "Unable to create data dirs [errorCode=" + ret + "]");
6873 if (dataPath.exists()) {
6874 pkg.applicationInfo.dataDir = dataPath.getPath();
6876 Slog.w(TAG, "Unable to create data directory: " + dataPath);
6877 pkg.applicationInfo.dataDir = null;
6881 pkgSetting.uidError = uidError;
6884 final String path = scanFile.getPath();
6885 final String cpuAbiOverride = deriveAbiOverride(pkg.cpuAbiOverride, pkgSetting);
6887 if ((scanFlags & SCAN_NEW_INSTALL) == 0) {
6888 derivePackageAbi(pkg, scanFile, cpuAbiOverride, true /* extract libs */);
6890 // Some system apps still use directory structure for native libraries
6891 // in which case we might end up not detecting abi solely based on apk
6892 // structure. Try to detect abi based on directory structure.
6893 if (isSystemApp(pkg) && !pkg.isUpdatedSystemApp() &&
6894 pkg.applicationInfo.primaryCpuAbi == null) {
6895 setBundledAppAbisAndRoots(pkg, pkgSetting);
6896 setNativeLibraryPaths(pkg);
6900 if ((scanFlags & SCAN_MOVE) != 0) {
6901 // We haven't run dex-opt for this move (since we've moved the compiled output too)
6902 // but we already have this packages package info in the PackageSetting. We just
6903 // use that and derive the native library path based on the new codepath.
6904 pkg.applicationInfo.primaryCpuAbi = pkgSetting.primaryCpuAbiString;
6905 pkg.applicationInfo.secondaryCpuAbi = pkgSetting.secondaryCpuAbiString;
6908 // Set native library paths again. For moves, the path will be updated based on the
6909 // ABIs we've determined above. For non-moves, the path will be updated based on the
6910 // ABIs we determined during compilation, but the path will depend on the final
6911 // package path (after the rename away from the stage path).
6912 setNativeLibraryPaths(pkg);
6915 if (DEBUG_INSTALL) Slog.i(TAG, "Linking native library dir for " + path);
6916 final int[] userIds = sUserManager.getUserIds();
6917 synchronized (mInstallLock) {
6918 // Make sure all user data directories are ready to roll; we're okay
6919 // if they already exist
6920 if (!TextUtils.isEmpty(pkg.volumeUuid)) {
6921 for (int userId : userIds) {
6923 mInstaller.createUserData(pkg.volumeUuid, pkg.packageName,
6924 UserHandle.getUid(userId, pkg.applicationInfo.uid), userId,
6925 pkg.applicationInfo.seinfo);
6930 // Create a native library symlink only if we have native libraries
6931 // and if the native libraries are 32 bit libraries. We do not provide
6932 // this symlink for 64 bit libraries.
6933 if (pkg.applicationInfo.primaryCpuAbi != null &&
6934 !VMRuntime.is64BitAbi(pkg.applicationInfo.primaryCpuAbi)) {
6935 final String nativeLibPath = pkg.applicationInfo.nativeLibraryDir;
6936 for (int userId : userIds) {
6937 if (mInstaller.linkNativeLibraryDirectory(pkg.volumeUuid, pkg.packageName,
6938 nativeLibPath, userId) < 0) {
6939 throw new PackageManagerException(INSTALL_FAILED_INTERNAL_ERROR,
6940 "Failed linking native library dir (user=" + userId + ")");
6946 // This is a special case for the "system" package, where the ABI is
6947 // dictated by the zygote configuration (and init.rc). We should keep track
6948 // of this ABI so that we can deal with "normal" applications that run under
6949 // the same UID correctly.
6950 if (mPlatformPackage == pkg) {
6951 pkg.applicationInfo.primaryCpuAbi = VMRuntime.getRuntime().is64Bit() ?
6952 Build.SUPPORTED_64_BIT_ABIS[0] : Build.SUPPORTED_32_BIT_ABIS[0];
6955 // If there's a mismatch between the abi-override in the package setting
6956 // and the abiOverride specified for the install. Warn about this because we
6957 // would've already compiled the app without taking the package setting into
6959 if ((scanFlags & SCAN_NO_DEX) == 0 && (scanFlags & SCAN_NEW_INSTALL) != 0) {
6960 if (cpuAbiOverride == null && pkgSetting.cpuAbiOverrideString != null) {
6961 Slog.w(TAG, "Ignoring persisted ABI override " + cpuAbiOverride +
6962 " for package: " + pkg.packageName);
6966 pkgSetting.primaryCpuAbiString = pkg.applicationInfo.primaryCpuAbi;
6967 pkgSetting.secondaryCpuAbiString = pkg.applicationInfo.secondaryCpuAbi;
6968 pkgSetting.cpuAbiOverrideString = cpuAbiOverride;
6970 // Copy the derived override back to the parsed package, so that we can
6971 // update the package settings accordingly.
6972 pkg.cpuAbiOverride = cpuAbiOverride;
6974 if (DEBUG_ABI_SELECTION) {
6975 Slog.d(TAG, "Resolved nativeLibraryRoot for " + pkg.applicationInfo.packageName
6976 + " to root=" + pkg.applicationInfo.nativeLibraryRootDir + ", isa="
6977 + pkg.applicationInfo.nativeLibraryRootRequiresIsa);
6980 // Push the derived path down into PackageSettings so we know what to
6981 // clean up at uninstall time.
6982 pkgSetting.legacyNativeLibraryPathString = pkg.applicationInfo.nativeLibraryRootDir;
6984 if (DEBUG_ABI_SELECTION) {
6985 Log.d(TAG, "Abis for package[" + pkg.packageName + "] are" +
6986 " primary=" + pkg.applicationInfo.primaryCpuAbi +
6987 " secondary=" + pkg.applicationInfo.secondaryCpuAbi);
6990 if ((scanFlags&SCAN_BOOTING) == 0 && pkgSetting.sharedUser != null) {
6991 // We don't do this here during boot because we can do it all
6992 // at once after scanning all existing packages.
6994 // We also do this *before* we perform dexopt on this package, so that
6995 // we can avoid redundant dexopts, and also to make sure we've got the
6996 // code and package path correct.
6997 adjustCpuAbisForSharedUserLPw(pkgSetting.sharedUser.packages,
6998 pkg, forceDex, (scanFlags & SCAN_DEFER_DEX) != 0);
7001 if ((scanFlags & SCAN_NO_DEX) == 0) {
7002 int result = mPackageDexOptimizer.performDexOpt(pkg, null /* instruction sets */,
7003 forceDex, (scanFlags & SCAN_DEFER_DEX) != 0, false /* inclDependencies */);
7004 if (result == PackageDexOptimizer.DEX_OPT_FAILED) {
7005 throw new PackageManagerException(INSTALL_FAILED_DEXOPT, "scanPackageLI");
7008 if (mFactoryTest && pkg.requestedPermissions.contains(
7009 android.Manifest.permission.FACTORY_TEST)) {
7010 pkg.applicationInfo.flags |= ApplicationInfo.FLAG_FACTORY_TEST;
7013 ArrayList<PackageParser.Package> clientLibPkgs = null;
7016 synchronized (mPackages) {
7017 if ((pkg.applicationInfo.flags&ApplicationInfo.FLAG_SYSTEM) != 0) {
7018 // Only system apps can add new shared libraries.
7019 if (pkg.libraryNames != null) {
7020 for (int i=0; i<pkg.libraryNames.size(); i++) {
7021 String name = pkg.libraryNames.get(i);
7022 boolean allowed = false;
7023 if (pkg.isUpdatedSystemApp()) {
7024 // New library entries can only be added through the
7025 // system image. This is important to get rid of a lot
7026 // of nasty edge cases: for example if we allowed a non-
7027 // system update of the app to add a library, then uninstalling
7028 // the update would make the library go away, and assumptions
7029 // we made such as through app install filtering would now
7030 // have allowed apps on the device which aren't compatible
7031 // with it. Better to just have the restriction here, be
7032 // conservative, and create many fewer cases that can negatively
7033 // impact the user experience.
7034 final PackageSetting sysPs = mSettings
7035 .getDisabledSystemPkgLPr(pkg.packageName);
7036 if (sysPs.pkg != null && sysPs.pkg.libraryNames != null) {
7037 for (int j=0; j<sysPs.pkg.libraryNames.size(); j++) {
7038 if (name.equals(sysPs.pkg.libraryNames.get(j))) {
7049 if (!mSharedLibraries.containsKey(name)) {
7050 mSharedLibraries.put(name, new SharedLibraryEntry(null, pkg.packageName));
7051 } else if (!name.equals(pkg.packageName)) {
7052 Slog.w(TAG, "Package " + pkg.packageName + " library "
7053 + name + " already exists; skipping");
7056 Slog.w(TAG, "Package " + pkg.packageName + " declares lib "
7057 + name + " that is not declared on system image; skipping");
7060 if ((scanFlags&SCAN_BOOTING) == 0) {
7061 // If we are not booting, we need to update any applications
7062 // that are clients of our shared library. If we are booting,
7063 // this will all be done once the scan is complete.
7064 clientLibPkgs = updateAllSharedLibrariesLPw(pkg);
7070 // We also need to dexopt any apps that are dependent on this library. Note that
7071 // if these fail, we should abort the install since installing the library will
7072 // result in some apps being broken.
7073 if (clientLibPkgs != null) {
7074 if ((scanFlags & SCAN_NO_DEX) == 0) {
7075 for (int i = 0; i < clientLibPkgs.size(); i++) {
7076 PackageParser.Package clientPkg = clientLibPkgs.get(i);
7077 int result = mPackageDexOptimizer.performDexOpt(clientPkg,
7078 null /* instruction sets */, forceDex,
7079 (scanFlags & SCAN_DEFER_DEX) != 0, false);
7080 if (result == PackageDexOptimizer.DEX_OPT_FAILED) {
7081 throw new PackageManagerException(INSTALL_FAILED_DEXOPT,
7082 "scanPackageLI failed to dexopt clientLibPkgs");
7088 // Also need to kill any apps that are dependent on the library.
7089 if (clientLibPkgs != null) {
7090 for (int i=0; i<clientLibPkgs.size(); i++) {
7091 PackageParser.Package clientPkg = clientLibPkgs.get(i);
7092 killApplication(clientPkg.applicationInfo.packageName,
7093 clientPkg.applicationInfo.uid, "update lib");
7097 // Make sure we're not adding any bogus keyset info
7098 KeySetManagerService ksms = mSettings.mKeySetManagerService;
7099 ksms.assertScannedPackageValid(pkg);
7102 synchronized (mPackages) {
7103 // We don't expect installation to fail beyond this point
7105 // Add the new setting to mSettings
7106 mSettings.insertPackageSettingLPw(pkgSetting, pkg);
7107 // Add the new setting to mPackages
7108 mPackages.put(pkg.applicationInfo.packageName, pkg);
7109 // Make sure we don't accidentally delete its data.
7110 final Iterator<PackageCleanItem> iter = mSettings.mPackagesToBeCleaned.iterator();
7111 while (iter.hasNext()) {
7112 PackageCleanItem item = iter.next();
7113 if (pkgName.equals(item.packageName)) {
7118 // Take care of first install / last update times.
7119 if (currentTime != 0) {
7120 if (pkgSetting.firstInstallTime == 0) {
7121 pkgSetting.firstInstallTime = pkgSetting.lastUpdateTime = currentTime;
7122 } else if ((scanFlags&SCAN_UPDATE_TIME) != 0) {
7123 pkgSetting.lastUpdateTime = currentTime;
7125 } else if (pkgSetting.firstInstallTime == 0) {
7126 // We need *something*. Take time time stamp of the file.
7127 pkgSetting.firstInstallTime = pkgSetting.lastUpdateTime = scanFileTime;
7128 } else if ((parseFlags&PackageParser.PARSE_IS_SYSTEM_DIR) != 0) {
7129 if (scanFileTime != pkgSetting.timeStamp) {
7130 // A package on the system image has changed; consider this
7132 pkgSetting.lastUpdateTime = scanFileTime;
7136 // Add the package's KeySets to the global KeySetManagerService
7137 ksms.addScannedPackageLPw(pkg);
7139 int N = pkg.providers.size();
7140 StringBuilder r = null;
7142 for (i=0; i<N; i++) {
7143 PackageParser.Provider p = pkg.providers.get(i);
7144 p.info.processName = fixProcessName(pkg.applicationInfo.processName,
7145 p.info.processName, pkg.applicationInfo.uid);
7146 mProviders.addProvider(p);
7147 p.syncable = p.info.isSyncable;
7148 if (p.info.authority != null) {
7149 String names[] = p.info.authority.split(";");
7150 p.info.authority = null;
7151 for (int j = 0; j < names.length; j++) {
7152 if (j == 1 && p.syncable) {
7153 // We only want the first authority for a provider to possibly be
7154 // syncable, so if we already added this provider using a different
7155 // authority clear the syncable flag. We copy the provider before
7156 // changing it because the mProviders object contains a reference
7157 // to a provider that we don't want to change.
7158 // Only do this for the second authority since the resulting provider
7159 // object can be the same for all future authorities for this provider.
7160 p = new PackageParser.Provider(p);
7163 if (!mProvidersByAuthority.containsKey(names[j])) {
7164 mProvidersByAuthority.put(names[j], p);
7165 if (p.info.authority == null) {
7166 p.info.authority = names[j];
7168 p.info.authority = p.info.authority + ";" + names[j];
7170 if (DEBUG_PACKAGE_SCANNING) {
7171 if ((parseFlags & PackageParser.PARSE_CHATTY) != 0)
7172 Log.d(TAG, "Registered content provider: " + names[j]
7173 + ", className = " + p.info.name + ", isSyncable = "
7174 + p.info.isSyncable);
7177 PackageParser.Provider other = mProvidersByAuthority.get(names[j]);
7178 Slog.w(TAG, "Skipping provider name " + names[j] +
7179 " (in package " + pkg.applicationInfo.packageName +
7180 "): name already used by "
7181 + ((other != null && other.getComponentName() != null)
7182 ? other.getComponentName().getPackageName() : "?"));
7186 if ((parseFlags&PackageParser.PARSE_CHATTY) != 0) {
7188 r = new StringBuilder(256);
7192 r.append(p.info.name);
7196 if (DEBUG_PACKAGE_SCANNING) Log.d(TAG, " Providers: " + r);
7199 N = pkg.services.size();
7201 for (i=0; i<N; i++) {
7202 PackageParser.Service s = pkg.services.get(i);
7203 s.info.processName = fixProcessName(pkg.applicationInfo.processName,
7204 s.info.processName, pkg.applicationInfo.uid);
7205 mServices.addService(s);
7206 if ((parseFlags&PackageParser.PARSE_CHATTY) != 0) {
7208 r = new StringBuilder(256);
7212 r.append(s.info.name);
7216 if (DEBUG_PACKAGE_SCANNING) Log.d(TAG, " Services: " + r);
7219 N = pkg.receivers.size();
7221 for (i=0; i<N; i++) {
7222 PackageParser.Activity a = pkg.receivers.get(i);
7223 a.info.processName = fixProcessName(pkg.applicationInfo.processName,
7224 a.info.processName, pkg.applicationInfo.uid);
7225 mReceivers.addActivity(a, "receiver");
7226 if ((parseFlags&PackageParser.PARSE_CHATTY) != 0) {
7228 r = new StringBuilder(256);
7232 r.append(a.info.name);
7236 if (DEBUG_PACKAGE_SCANNING) Log.d(TAG, " Receivers: " + r);
7239 N = pkg.activities.size();
7241 for (i=0; i<N; i++) {
7242 PackageParser.Activity a = pkg.activities.get(i);
7243 a.info.processName = fixProcessName(pkg.applicationInfo.processName,
7244 a.info.processName, pkg.applicationInfo.uid);
7245 mActivities.addActivity(a, "activity");
7246 if ((parseFlags&PackageParser.PARSE_CHATTY) != 0) {
7248 r = new StringBuilder(256);
7252 r.append(a.info.name);
7256 if (DEBUG_PACKAGE_SCANNING) Log.d(TAG, " Activities: " + r);
7259 N = pkg.permissionGroups.size();
7261 for (i=0; i<N; i++) {
7262 PackageParser.PermissionGroup pg = pkg.permissionGroups.get(i);
7263 PackageParser.PermissionGroup cur = mPermissionGroups.get(pg.info.name);
7265 mPermissionGroups.put(pg.info.name, pg);
7266 if ((parseFlags&PackageParser.PARSE_CHATTY) != 0) {
7268 r = new StringBuilder(256);
7272 r.append(pg.info.name);
7275 Slog.w(TAG, "Permission group " + pg.info.name + " from package "
7276 + pg.info.packageName + " ignored: original from "
7277 + cur.info.packageName);
7278 if ((parseFlags&PackageParser.PARSE_CHATTY) != 0) {
7280 r = new StringBuilder(256);
7285 r.append(pg.info.name);
7290 if (DEBUG_PACKAGE_SCANNING) Log.d(TAG, " Permission Groups: " + r);
7293 N = pkg.permissions.size();
7295 for (i=0; i<N; i++) {
7296 PackageParser.Permission p = pkg.permissions.get(i);
7298 // Now that permission groups have a special meaning, we ignore permission
7299 // groups for legacy apps to prevent unexpected behavior. In particular,
7300 // permissions for one app being granted to someone just becuase they happen
7301 // to be in a group defined by another app (before this had no implications).
7302 if (pkg.applicationInfo.targetSdkVersion > Build.VERSION_CODES.LOLLIPOP_MR1) {
7303 p.group = mPermissionGroups.get(p.info.group);
7304 // Warn for a permission in an unknown group.
7305 if (p.info.group != null && p.group == null) {
7306 Slog.w(TAG, "Permission " + p.info.name + " from package "
7307 + p.info.packageName + " in an unknown group " + p.info.group);
7311 ArrayMap<String, BasePermission> permissionMap =
7312 p.tree ? mSettings.mPermissionTrees
7313 : mSettings.mPermissions;
7314 BasePermission bp = permissionMap.get(p.info.name);
7316 // Allow system apps to redefine non-system permissions
7317 if (bp != null && !Objects.equals(bp.sourcePackage, p.info.packageName)) {
7318 final boolean currentOwnerIsSystem = (bp.perm != null
7319 && isSystemApp(bp.perm.owner));
7320 if (isSystemApp(p.owner)) {
7321 if (bp.type == BasePermission.TYPE_BUILTIN && bp.perm == null) {
7322 // It's a built-in permission and no owner, take ownership now
7323 bp.packageSetting = pkgSetting;
7325 bp.uid = pkg.applicationInfo.uid;
7326 bp.sourcePackage = p.info.packageName;
7327 } else if (!currentOwnerIsSystem) {
7328 String msg = "New decl " + p.owner + " of permission "
7329 + p.info.name + " is system; overriding " + bp.sourcePackage;
7330 reportSettingsProblem(Log.WARN, msg);
7337 bp = new BasePermission(p.info.name, p.info.packageName,
7338 BasePermission.TYPE_NORMAL);
7339 permissionMap.put(p.info.name, bp);
7342 if (bp.perm == null) {
7343 if (bp.sourcePackage == null
7344 || bp.sourcePackage.equals(p.info.packageName)) {
7345 BasePermission tree = findPermissionTreeLP(p.info.name);
7347 || tree.sourcePackage.equals(p.info.packageName)) {
7348 bp.packageSetting = pkgSetting;
7350 bp.uid = pkg.applicationInfo.uid;
7351 bp.sourcePackage = p.info.packageName;
7352 if ((parseFlags&PackageParser.PARSE_CHATTY) != 0) {
7354 r = new StringBuilder(256);
7358 r.append(p.info.name);
7361 Slog.w(TAG, "Permission " + p.info.name + " from package "
7362 + p.info.packageName + " ignored: base tree "
7363 + tree.name + " is from package "
7364 + tree.sourcePackage);
7367 Slog.w(TAG, "Permission " + p.info.name + " from package "
7368 + p.info.packageName + " ignored: original from "
7369 + bp.sourcePackage);
7371 } else if ((parseFlags&PackageParser.PARSE_CHATTY) != 0) {
7373 r = new StringBuilder(256);
7378 r.append(p.info.name);
7381 bp.protectionLevel = p.info.protectionLevel;
7386 if (DEBUG_PACKAGE_SCANNING) Log.d(TAG, " Permissions: " + r);
7389 N = pkg.instrumentation.size();
7391 for (i=0; i<N; i++) {
7392 PackageParser.Instrumentation a = pkg.instrumentation.get(i);
7393 a.info.packageName = pkg.applicationInfo.packageName;
7394 a.info.sourceDir = pkg.applicationInfo.sourceDir;
7395 a.info.publicSourceDir = pkg.applicationInfo.publicSourceDir;
7396 a.info.splitSourceDirs = pkg.applicationInfo.splitSourceDirs;
7397 a.info.splitPublicSourceDirs = pkg.applicationInfo.splitPublicSourceDirs;
7398 a.info.dataDir = pkg.applicationInfo.dataDir;
7400 // TODO: Update instrumentation.nativeLibraryDir as well ? Does it
7401 // need other information about the application, like the ABI and what not ?
7402 a.info.nativeLibraryDir = pkg.applicationInfo.nativeLibraryDir;
7403 mInstrumentation.put(a.getComponentName(), a);
7404 if ((parseFlags&PackageParser.PARSE_CHATTY) != 0) {
7406 r = new StringBuilder(256);
7410 r.append(a.info.name);
7414 if (DEBUG_PACKAGE_SCANNING) Log.d(TAG, " Instrumentation: " + r);
7417 if (pkg.protectedBroadcasts != null) {
7418 N = pkg.protectedBroadcasts.size();
7419 for (i=0; i<N; i++) {
7420 mProtectedBroadcasts.add(pkg.protectedBroadcasts.get(i));
7424 pkgSetting.setTimeStamp(scanFileTime);
7426 // Create idmap files for pairs of (packages, overlay packages).
7427 // Note: "android", ie framework-res.apk, is handled by native layers.
7428 if (pkg.mOverlayTarget != null) {
7429 // This is an overlay package.
7430 if (pkg.mOverlayTarget != null && !pkg.mOverlayTarget.equals("android")) {
7431 if (!mOverlays.containsKey(pkg.mOverlayTarget)) {
7432 mOverlays.put(pkg.mOverlayTarget,
7433 new ArrayMap<String, PackageParser.Package>());
7435 ArrayMap<String, PackageParser.Package> map = mOverlays.get(pkg.mOverlayTarget);
7436 map.put(pkg.packageName, pkg);
7437 PackageParser.Package orig = mPackages.get(pkg.mOverlayTarget);
7438 if (orig != null && !createIdmapForPackagePairLI(orig, pkg)) {
7439 throw new PackageManagerException(INSTALL_FAILED_UPDATE_INCOMPATIBLE,
7440 "scanPackageLI failed to createIdmap");
7443 } else if (mOverlays.containsKey(pkg.packageName) &&
7444 !pkg.packageName.equals("android")) {
7445 // This is a regular package, with one or more known overlay packages.
7446 createIdmapsForPackageLI(pkg);
7454 * Derive the ABI of a non-system package located at {@code scanFile}. This information
7455 * is derived purely on the basis of the contents of {@code scanFile} and
7456 * {@code cpuAbiOverride}.
7458 * If {@code extractLibs} is true, native libraries are extracted from the app if required.
7460 public void derivePackageAbi(PackageParser.Package pkg, File scanFile,
7461 String cpuAbiOverride, boolean extractLibs)
7462 throws PackageManagerException {
7463 // TODO: We can probably be smarter about this stuff. For installed apps,
7464 // we can calculate this information at install time once and for all. For
7465 // system apps, we can probably assume that this information doesn't change
7466 // after the first boot scan. As things stand, we do lots of unnecessary work.
7468 // Give ourselves some initial paths; we'll come back for another
7469 // pass once we've determined ABI below.
7470 setNativeLibraryPaths(pkg);
7472 // We would never need to extract libs for forward-locked and external packages,
7473 // since the container service will do it for us. We shouldn't attempt to
7474 // extract libs from system app when it was not updated.
7475 if (pkg.isForwardLocked() || isExternal(pkg) ||
7476 (isSystemApp(pkg) && !pkg.isUpdatedSystemApp()) ) {
7477 extractLibs = false;
7480 final String nativeLibraryRootStr = pkg.applicationInfo.nativeLibraryRootDir;
7481 final boolean useIsaSpecificSubdirs = pkg.applicationInfo.nativeLibraryRootRequiresIsa;
7483 NativeLibraryHelper.Handle handle = null;
7485 handle = NativeLibraryHelper.Handle.create(scanFile);
7486 // TODO(multiArch): This can be null for apps that didn't go through the
7487 // usual installation process. We can calculate it again, like we
7488 // do during install time.
7490 // TODO(multiArch): Why do we need to rescan ASEC apps again ? It seems totally
7492 final File nativeLibraryRoot = new File(nativeLibraryRootStr);
7494 // Null out the abis so that they can be recalculated.
7495 pkg.applicationInfo.primaryCpuAbi = null;
7496 pkg.applicationInfo.secondaryCpuAbi = null;
7497 if (isMultiArch(pkg.applicationInfo)) {
7498 // Warn if we've set an abiOverride for multi-lib packages..
7499 // By definition, we need to copy both 32 and 64 bit libraries for
7501 if (pkg.cpuAbiOverride != null
7502 && !NativeLibraryHelper.CLEAR_ABI_OVERRIDE.equals(pkg.cpuAbiOverride)) {
7503 Slog.w(TAG, "Ignoring abiOverride for multi arch application.");
7506 int abi32 = PackageManager.NO_NATIVE_LIBRARIES;
7507 int abi64 = PackageManager.NO_NATIVE_LIBRARIES;
7508 if (Build.SUPPORTED_32_BIT_ABIS.length > 0) {
7510 abi32 = NativeLibraryHelper.copyNativeBinariesForSupportedAbi(handle,
7511 nativeLibraryRoot, Build.SUPPORTED_32_BIT_ABIS,
7512 useIsaSpecificSubdirs);
7514 abi32 = NativeLibraryHelper.findSupportedAbi(handle, Build.SUPPORTED_32_BIT_ABIS);
7518 maybeThrowExceptionForMultiArchCopy(
7519 "Error unpackaging 32 bit native libs for multiarch app.", abi32);
7521 if (Build.SUPPORTED_64_BIT_ABIS.length > 0) {
7523 abi64 = NativeLibraryHelper.copyNativeBinariesForSupportedAbi(handle,
7524 nativeLibraryRoot, Build.SUPPORTED_64_BIT_ABIS,
7525 useIsaSpecificSubdirs);
7527 abi64 = NativeLibraryHelper.findSupportedAbi(handle, Build.SUPPORTED_64_BIT_ABIS);
7531 maybeThrowExceptionForMultiArchCopy(
7532 "Error unpackaging 64 bit native libs for multiarch app.", abi64);
7535 pkg.applicationInfo.primaryCpuAbi = Build.SUPPORTED_64_BIT_ABIS[abi64];
7539 final String abi = Build.SUPPORTED_32_BIT_ABIS[abi32];
7541 pkg.applicationInfo.secondaryCpuAbi = abi;
7543 pkg.applicationInfo.primaryCpuAbi = abi;
7547 String[] abiList = (cpuAbiOverride != null) ?
7548 new String[] { cpuAbiOverride } : Build.SUPPORTED_ABIS;
7550 // Enable gross and lame hacks for apps that are built with old
7551 // SDK tools. We must scan their APKs for renderscript bitcode and
7552 // not launch them if it's present. Don't bother checking on devices
7553 // that don't have 64 bit support.
7554 boolean needsRenderScriptOverride = false;
7555 if (Build.SUPPORTED_64_BIT_ABIS.length > 0 && cpuAbiOverride == null &&
7556 NativeLibraryHelper.hasRenderscriptBitcode(handle)) {
7557 abiList = Build.SUPPORTED_32_BIT_ABIS;
7558 needsRenderScriptOverride = true;
7563 copyRet = NativeLibraryHelper.copyNativeBinariesForSupportedAbi(handle,
7564 nativeLibraryRoot, abiList, useIsaSpecificSubdirs);
7566 copyRet = NativeLibraryHelper.findSupportedAbi(handle, abiList);
7569 if (copyRet < 0 && copyRet != PackageManager.NO_NATIVE_LIBRARIES) {
7570 throw new PackageManagerException(INSTALL_FAILED_INTERNAL_ERROR,
7571 "Error unpackaging native libs for app, errorCode=" + copyRet);
7575 pkg.applicationInfo.primaryCpuAbi = abiList[copyRet];
7576 } else if (copyRet == PackageManager.NO_NATIVE_LIBRARIES && cpuAbiOverride != null) {
7577 pkg.applicationInfo.primaryCpuAbi = cpuAbiOverride;
7578 } else if (needsRenderScriptOverride) {
7579 pkg.applicationInfo.primaryCpuAbi = abiList[0];
7582 } catch (IOException ioe) {
7583 Slog.e(TAG, "Unable to get canonical file " + ioe.toString());
7585 IoUtils.closeQuietly(handle);
7588 // Now that we've calculated the ABIs and determined if it's an internal app,
7589 // we will go ahead and populate the nativeLibraryPath.
7590 setNativeLibraryPaths(pkg);
7594 * Adjusts ABIs for a set of packages belonging to a shared user so that they all match.
7595 * i.e, so that all packages can be run inside a single process if required.
7597 * Optionally, callers can pass in a parsed package via {@code newPackage} in which case
7598 * this function will either try and make the ABI for all packages in {@code packagesForUser}
7599 * match {@code scannedPackage} or will update the ABI of {@code scannedPackage} to match
7600 * the ABI selected for {@code packagesForUser}. This variant is used when installing or
7601 * updating a package that belongs to a shared user.
7603 * NOTE: We currently only match for the primary CPU abi string. Matching the secondary
7604 * adds unnecessary complexity.
7606 private void adjustCpuAbisForSharedUserLPw(Set<PackageSetting> packagesForUser,
7607 PackageParser.Package scannedPackage, boolean forceDexOpt, boolean deferDexOpt) {
7608 String requiredInstructionSet = null;
7609 if (scannedPackage != null && scannedPackage.applicationInfo.primaryCpuAbi != null) {
7610 requiredInstructionSet = VMRuntime.getInstructionSet(
7611 scannedPackage.applicationInfo.primaryCpuAbi);
7614 PackageSetting requirer = null;
7615 for (PackageSetting ps : packagesForUser) {
7616 // If packagesForUser contains scannedPackage, we skip it. This will happen
7617 // when scannedPackage is an update of an existing package. Without this check,
7618 // we will never be able to change the ABI of any package belonging to a shared
7619 // user, even if it's compatible with other packages.
7620 if (scannedPackage == null || !scannedPackage.packageName.equals(ps.name)) {
7621 if (ps.primaryCpuAbiString == null) {
7625 final String instructionSet = VMRuntime.getInstructionSet(ps.primaryCpuAbiString);
7626 if (requiredInstructionSet != null && !instructionSet.equals(requiredInstructionSet)) {
7627 // We have a mismatch between instruction sets (say arm vs arm64) warn about
7628 // this but there's not much we can do.
7629 String errorMessage = "Instruction set mismatch, "
7630 + ((requirer == null) ? "[caller]" : requirer)
7631 + " requires " + requiredInstructionSet + " whereas " + ps
7632 + " requires " + instructionSet;
7633 Slog.w(TAG, errorMessage);
7636 if (requiredInstructionSet == null) {
7637 requiredInstructionSet = instructionSet;
7643 if (requiredInstructionSet != null) {
7645 if (requirer != null) {
7646 // requirer != null implies that either scannedPackage was null or that scannedPackage
7647 // did not require an ABI, in which case we have to adjust scannedPackage to match
7648 // the ABI of the set (which is the same as requirer's ABI)
7649 adjustedAbi = requirer.primaryCpuAbiString;
7650 if (scannedPackage != null) {
7651 scannedPackage.applicationInfo.primaryCpuAbi = adjustedAbi;
7654 // requirer == null implies that we're updating all ABIs in the set to
7655 // match scannedPackage.
7656 adjustedAbi = scannedPackage.applicationInfo.primaryCpuAbi;
7659 for (PackageSetting ps : packagesForUser) {
7660 if (scannedPackage == null || !scannedPackage.packageName.equals(ps.name)) {
7661 if (ps.primaryCpuAbiString != null) {
7665 ps.primaryCpuAbiString = adjustedAbi;
7666 if (ps.pkg != null && ps.pkg.applicationInfo != null) {
7667 ps.pkg.applicationInfo.primaryCpuAbi = adjustedAbi;
7668 Slog.i(TAG, "Adjusting ABI for : " + ps.name + " to " + adjustedAbi);
7670 int result = mPackageDexOptimizer.performDexOpt(ps.pkg,
7671 null /* instruction sets */, forceDexOpt, deferDexOpt, true);
7672 if (result == PackageDexOptimizer.DEX_OPT_FAILED) {
7673 ps.primaryCpuAbiString = null;
7674 ps.pkg.applicationInfo.primaryCpuAbi = null;
7677 mInstaller.rmdex(ps.codePathString,
7678 getDexCodeInstructionSet(getPreferredInstructionSet()));
7686 private void setUpCustomResolverActivity(PackageParser.Package pkg) {
7687 synchronized (mPackages) {
7688 mResolverReplaced = true;
7689 // Set up information for custom user intent resolution activity.
7690 mResolveActivity.applicationInfo = pkg.applicationInfo;
7691 mResolveActivity.name = mCustomResolverComponentName.getClassName();
7692 mResolveActivity.packageName = pkg.applicationInfo.packageName;
7693 mResolveActivity.processName = pkg.applicationInfo.packageName;
7694 mResolveActivity.launchMode = ActivityInfo.LAUNCH_MULTIPLE;
7695 mResolveActivity.flags = ActivityInfo.FLAG_EXCLUDE_FROM_RECENTS |
7696 ActivityInfo.FLAG_FINISH_ON_CLOSE_SYSTEM_DIALOGS;
7697 mResolveActivity.theme = 0;
7698 mResolveActivity.exported = true;
7699 mResolveActivity.enabled = true;
7700 mResolveInfo.activityInfo = mResolveActivity;
7701 mResolveInfo.priority = 0;
7702 mResolveInfo.preferredOrder = 0;
7703 mResolveInfo.match = 0;
7704 mResolveComponentName = mCustomResolverComponentName;
7705 Slog.i(TAG, "Replacing default ResolverActivity with custom activity: " +
7706 mResolveComponentName);
7710 private static String calculateBundledApkRoot(final String codePathString) {
7711 final File codePath = new File(codePathString);
7712 final File codeRoot;
7713 if (FileUtils.contains(Environment.getRootDirectory(), codePath)) {
7714 codeRoot = Environment.getRootDirectory();
7715 } else if (FileUtils.contains(Environment.getOemDirectory(), codePath)) {
7716 codeRoot = Environment.getOemDirectory();
7717 } else if (FileUtils.contains(Environment.getVendorDirectory(), codePath)) {
7718 codeRoot = Environment.getVendorDirectory();
7720 // Unrecognized code path; take its top real segment as the apk root:
7721 // e.g. /something/app/blah.apk => /something
7723 File f = codePath.getCanonicalFile();
7724 File parent = f.getParentFile(); // non-null because codePath is a file
7726 while ((tmp = parent.getParentFile()) != null) {
7731 Slog.w(TAG, "Unrecognized code path "
7732 + codePath + " - using " + codeRoot);
7733 } catch (IOException e) {
7734 // Can't canonicalize the code path -- shenanigans?
7735 Slog.w(TAG, "Can't canonicalize code path " + codePath);
7736 return Environment.getRootDirectory().getPath();
7739 return codeRoot.getPath();
7743 * Derive and set the location of native libraries for the given package,
7744 * which varies depending on where and how the package was installed.
7746 private void setNativeLibraryPaths(PackageParser.Package pkg) {
7747 final ApplicationInfo info = pkg.applicationInfo;
7748 final String codePath = pkg.codePath;
7749 final File codeFile = new File(codePath);
7750 final boolean bundledApp = info.isSystemApp() && !info.isUpdatedSystemApp();
7751 final boolean asecApp = info.isForwardLocked() || isExternal(info);
7753 info.nativeLibraryRootDir = null;
7754 info.nativeLibraryRootRequiresIsa = false;
7755 info.nativeLibraryDir = null;
7756 info.secondaryNativeLibraryDir = null;
7758 if (isApkFile(codeFile)) {
7759 // Monolithic install
7761 // If "/system/lib64/apkname" exists, assume that is the per-package
7762 // native library directory to use; otherwise use "/system/lib/apkname".
7763 final String apkRoot = calculateBundledApkRoot(info.sourceDir);
7764 final boolean is64Bit = VMRuntime.is64BitInstructionSet(
7765 getPrimaryInstructionSet(info));
7767 // This is a bundled system app so choose the path based on the ABI.
7768 // if it's a 64 bit abi, use lib64 otherwise use lib32. Note that this
7769 // is just the default path.
7770 final String apkName = deriveCodePathName(codePath);
7771 final String libDir = is64Bit ? LIB64_DIR_NAME : LIB_DIR_NAME;
7772 info.nativeLibraryRootDir = Environment.buildPath(new File(apkRoot), libDir,
7773 apkName).getAbsolutePath();
7775 if (info.secondaryCpuAbi != null) {
7776 final String secondaryLibDir = is64Bit ? LIB_DIR_NAME : LIB64_DIR_NAME;
7777 info.secondaryNativeLibraryDir = Environment.buildPath(new File(apkRoot),
7778 secondaryLibDir, apkName).getAbsolutePath();
7780 } else if (asecApp) {
7781 info.nativeLibraryRootDir = new File(codeFile.getParentFile(), LIB_DIR_NAME)
7784 final String apkName = deriveCodePathName(codePath);
7785 info.nativeLibraryRootDir = new File(mAppLib32InstallDir, apkName)
7789 info.nativeLibraryRootRequiresIsa = false;
7790 info.nativeLibraryDir = info.nativeLibraryRootDir;
7793 info.nativeLibraryRootDir = new File(codeFile, LIB_DIR_NAME).getAbsolutePath();
7794 info.nativeLibraryRootRequiresIsa = true;
7796 info.nativeLibraryDir = new File(info.nativeLibraryRootDir,
7797 getPrimaryInstructionSet(info)).getAbsolutePath();
7799 if (info.secondaryCpuAbi != null) {
7800 info.secondaryNativeLibraryDir = new File(info.nativeLibraryRootDir,
7801 VMRuntime.getInstructionSet(info.secondaryCpuAbi)).getAbsolutePath();
7807 * Calculate the abis and roots for a bundled app. These can uniquely
7808 * be determined from the contents of the system partition, i.e whether
7809 * it contains 64 or 32 bit shared libraries etc. We do not validate any
7810 * of this information, and instead assume that the system was built
7813 private void setBundledAppAbisAndRoots(PackageParser.Package pkg,
7814 PackageSetting pkgSetting) {
7815 final String apkName = deriveCodePathName(pkg.applicationInfo.getCodePath());
7817 // If "/system/lib64/apkname" exists, assume that is the per-package
7818 // native library directory to use; otherwise use "/system/lib/apkname".
7819 final String apkRoot = calculateBundledApkRoot(pkg.applicationInfo.sourceDir);
7820 setBundledAppAbi(pkg, apkRoot, apkName);
7821 // pkgSetting might be null during rescan following uninstall of updates
7822 // to a bundled app, so accommodate that possibility. The settings in
7823 // that case will be established later from the parsed package.
7825 // If the settings aren't null, sync them up with what we've just derived.
7826 // note that apkRoot isn't stored in the package settings.
7827 if (pkgSetting != null) {
7828 pkgSetting.primaryCpuAbiString = pkg.applicationInfo.primaryCpuAbi;
7829 pkgSetting.secondaryCpuAbiString = pkg.applicationInfo.secondaryCpuAbi;
7834 * Deduces the ABI of a bundled app and sets the relevant fields on the
7835 * parsed pkg object.
7837 * @param apkRoot the root of the installed apk, something like {@code /system} or {@code /oem}
7838 * under which system libraries are installed.
7839 * @param apkName the name of the installed package.
7841 private static void setBundledAppAbi(PackageParser.Package pkg, String apkRoot, String apkName) {
7842 final File codeFile = new File(pkg.codePath);
7844 final boolean has64BitLibs;
7845 final boolean has32BitLibs;
7846 if (isApkFile(codeFile)) {
7847 // Monolithic install
7848 has64BitLibs = (new File(apkRoot, new File(LIB64_DIR_NAME, apkName).getPath())).exists();
7849 has32BitLibs = (new File(apkRoot, new File(LIB_DIR_NAME, apkName).getPath())).exists();
7852 final File rootDir = new File(codeFile, LIB_DIR_NAME);
7853 if (!ArrayUtils.isEmpty(Build.SUPPORTED_64_BIT_ABIS)
7854 && !TextUtils.isEmpty(Build.SUPPORTED_64_BIT_ABIS[0])) {
7855 final String isa = VMRuntime.getInstructionSet(Build.SUPPORTED_64_BIT_ABIS[0]);
7856 has64BitLibs = (new File(rootDir, isa)).exists();
7858 has64BitLibs = false;
7860 if (!ArrayUtils.isEmpty(Build.SUPPORTED_32_BIT_ABIS)
7861 && !TextUtils.isEmpty(Build.SUPPORTED_32_BIT_ABIS[0])) {
7862 final String isa = VMRuntime.getInstructionSet(Build.SUPPORTED_32_BIT_ABIS[0]);
7863 has32BitLibs = (new File(rootDir, isa)).exists();
7865 has32BitLibs = false;
7869 if (has64BitLibs && !has32BitLibs) {
7870 // The package has 64 bit libs, but not 32 bit libs. Its primary
7871 // ABI should be 64 bit. We can safely assume here that the bundled
7872 // native libraries correspond to the most preferred ABI in the list.
7874 pkg.applicationInfo.primaryCpuAbi = Build.SUPPORTED_64_BIT_ABIS[0];
7875 pkg.applicationInfo.secondaryCpuAbi = null;
7876 } else if (has32BitLibs && !has64BitLibs) {
7877 // The package has 32 bit libs but not 64 bit libs. Its primary
7878 // ABI should be 32 bit.
7880 pkg.applicationInfo.primaryCpuAbi = Build.SUPPORTED_32_BIT_ABIS[0];
7881 pkg.applicationInfo.secondaryCpuAbi = null;
7882 } else if (has32BitLibs && has64BitLibs) {
7883 // The application has both 64 and 32 bit bundled libraries. We check
7884 // here that the app declares multiArch support, and warn if it doesn't.
7886 // We will be lenient here and record both ABIs. The primary will be the
7887 // ABI that's higher on the list, i.e, a device that's configured to prefer
7888 // 64 bit apps will see a 64 bit primary ABI,
7890 if ((pkg.applicationInfo.flags & ApplicationInfo.FLAG_MULTIARCH) == 0) {
7891 Slog.e(TAG, "Package: " + pkg + " has multiple bundled libs, but is not multiarch.");
7894 if (VMRuntime.is64BitInstructionSet(getPreferredInstructionSet())) {
7895 pkg.applicationInfo.primaryCpuAbi = Build.SUPPORTED_64_BIT_ABIS[0];
7896 pkg.applicationInfo.secondaryCpuAbi = Build.SUPPORTED_32_BIT_ABIS[0];
7898 pkg.applicationInfo.primaryCpuAbi = Build.SUPPORTED_32_BIT_ABIS[0];
7899 pkg.applicationInfo.secondaryCpuAbi = Build.SUPPORTED_64_BIT_ABIS[0];
7902 pkg.applicationInfo.primaryCpuAbi = null;
7903 pkg.applicationInfo.secondaryCpuAbi = null;
7907 private void killApplication(String pkgName, int appId, String reason) {
7908 // Request the ActivityManager to kill the process(only for existing packages)
7909 // so that we do not end up in a confused state while the user is still using the older
7910 // version of the application while the new one gets installed.
7911 IActivityManager am = ActivityManagerNative.getDefault();
7914 am.killApplicationWithAppId(pkgName, appId, reason);
7915 } catch (RemoteException e) {
7920 void removePackageLI(PackageSetting ps, boolean chatty) {
7921 if (DEBUG_INSTALL) {
7923 Log.d(TAG, "Removing package " + ps.name);
7927 synchronized (mPackages) {
7928 mPackages.remove(ps.name);
7929 final PackageParser.Package pkg = ps.pkg;
7931 cleanPackageDataStructuresLILPw(pkg, chatty);
7936 void removeInstalledPackageLI(PackageParser.Package pkg, boolean chatty) {
7937 if (DEBUG_INSTALL) {
7939 Log.d(TAG, "Removing package " + pkg.applicationInfo.packageName);
7943 synchronized (mPackages) {
7944 mPackages.remove(pkg.applicationInfo.packageName);
7945 cleanPackageDataStructuresLILPw(pkg, chatty);
7949 void cleanPackageDataStructuresLILPw(PackageParser.Package pkg, boolean chatty) {
7950 int N = pkg.providers.size();
7951 StringBuilder r = null;
7953 for (i=0; i<N; i++) {
7954 PackageParser.Provider p = pkg.providers.get(i);
7955 mProviders.removeProvider(p);
7956 if (p.info.authority == null) {
7958 /* There was another ContentProvider with this authority when
7959 * this app was installed so this authority is null,
7960 * Ignore it as we don't have to unregister the provider.
7964 String names[] = p.info.authority.split(";");
7965 for (int j = 0; j < names.length; j++) {
7966 if (mProvidersByAuthority.get(names[j]) == p) {
7967 mProvidersByAuthority.remove(names[j]);
7970 Log.d(TAG, "Unregistered content provider: " + names[j]
7971 + ", className = " + p.info.name + ", isSyncable = "
7972 + p.info.isSyncable);
7976 if (DEBUG_REMOVE && chatty) {
7978 r = new StringBuilder(256);
7982 r.append(p.info.name);
7986 if (DEBUG_REMOVE) Log.d(TAG, " Providers: " + r);
7989 N = pkg.services.size();
7991 for (i=0; i<N; i++) {
7992 PackageParser.Service s = pkg.services.get(i);
7993 mServices.removeService(s);
7996 r = new StringBuilder(256);
8000 r.append(s.info.name);
8004 if (DEBUG_REMOVE) Log.d(TAG, " Services: " + r);
8007 N = pkg.receivers.size();
8009 for (i=0; i<N; i++) {
8010 PackageParser.Activity a = pkg.receivers.get(i);
8011 mReceivers.removeActivity(a, "receiver");
8012 if (DEBUG_REMOVE && chatty) {
8014 r = new StringBuilder(256);
8018 r.append(a.info.name);
8022 if (DEBUG_REMOVE) Log.d(TAG, " Receivers: " + r);
8025 N = pkg.activities.size();
8027 for (i=0; i<N; i++) {
8028 PackageParser.Activity a = pkg.activities.get(i);
8029 mActivities.removeActivity(a, "activity");
8030 if (DEBUG_REMOVE && chatty) {
8032 r = new StringBuilder(256);
8036 r.append(a.info.name);
8040 if (DEBUG_REMOVE) Log.d(TAG, " Activities: " + r);
8043 N = pkg.permissions.size();
8045 for (i=0; i<N; i++) {
8046 PackageParser.Permission p = pkg.permissions.get(i);
8047 BasePermission bp = mSettings.mPermissions.get(p.info.name);
8049 bp = mSettings.mPermissionTrees.get(p.info.name);
8051 if (bp != null && bp.perm == p) {
8053 if (DEBUG_REMOVE && chatty) {
8055 r = new StringBuilder(256);
8059 r.append(p.info.name);
8062 if ((p.info.protectionLevel&PermissionInfo.PROTECTION_FLAG_APPOP) != 0) {
8063 ArraySet<String> appOpPerms = mAppOpPermissionPackages.get(p.info.name);
8064 if (appOpPerms != null) {
8065 appOpPerms.remove(pkg.packageName);
8070 if (DEBUG_REMOVE) Log.d(TAG, " Permissions: " + r);
8073 N = pkg.requestedPermissions.size();
8075 for (i=0; i<N; i++) {
8076 String perm = pkg.requestedPermissions.get(i);
8077 BasePermission bp = mSettings.mPermissions.get(perm);
8078 if (bp != null && (bp.protectionLevel&PermissionInfo.PROTECTION_FLAG_APPOP) != 0) {
8079 ArraySet<String> appOpPerms = mAppOpPermissionPackages.get(perm);
8080 if (appOpPerms != null) {
8081 appOpPerms.remove(pkg.packageName);
8082 if (appOpPerms.isEmpty()) {
8083 mAppOpPermissionPackages.remove(perm);
8089 if (DEBUG_REMOVE) Log.d(TAG, " Permissions: " + r);
8092 N = pkg.instrumentation.size();
8094 for (i=0; i<N; i++) {
8095 PackageParser.Instrumentation a = pkg.instrumentation.get(i);
8096 mInstrumentation.remove(a.getComponentName());
8097 if (DEBUG_REMOVE && chatty) {
8099 r = new StringBuilder(256);
8103 r.append(a.info.name);
8107 if (DEBUG_REMOVE) Log.d(TAG, " Instrumentation: " + r);
8111 if ((pkg.applicationInfo.flags&ApplicationInfo.FLAG_SYSTEM) != 0) {
8112 // Only system apps can hold shared libraries.
8113 if (pkg.libraryNames != null) {
8114 for (i=0; i<pkg.libraryNames.size(); i++) {
8115 String name = pkg.libraryNames.get(i);
8116 SharedLibraryEntry cur = mSharedLibraries.get(name);
8117 if (cur != null && cur.apk != null && cur.apk.equals(pkg.packageName)) {
8118 mSharedLibraries.remove(name);
8119 if (DEBUG_REMOVE && chatty) {
8121 r = new StringBuilder(256);
8132 if (DEBUG_REMOVE) Log.d(TAG, " Libraries: " + r);
8136 private static boolean hasPermission(PackageParser.Package pkgInfo, String perm) {
8137 for (int i=pkgInfo.permissions.size()-1; i>=0; i--) {
8138 if (pkgInfo.permissions.get(i).info.name.equals(perm)) {
8145 static final int UPDATE_PERMISSIONS_ALL = 1<<0;
8146 static final int UPDATE_PERMISSIONS_REPLACE_PKG = 1<<1;
8147 static final int UPDATE_PERMISSIONS_REPLACE_ALL = 1<<2;
8149 private void updatePermissionsLPw(String changingPkg,
8150 PackageParser.Package pkgInfo, int flags) {
8151 // Make sure there are no dangling permission trees.
8152 Iterator<BasePermission> it = mSettings.mPermissionTrees.values().iterator();
8153 while (it.hasNext()) {
8154 final BasePermission bp = it.next();
8155 if (bp.packageSetting == null) {
8156 // We may not yet have parsed the package, so just see if
8157 // we still know about its settings.
8158 bp.packageSetting = mSettings.mPackages.get(bp.sourcePackage);
8160 if (bp.packageSetting == null) {
8161 Slog.w(TAG, "Removing dangling permission tree: " + bp.name
8162 + " from package " + bp.sourcePackage);
8164 } else if (changingPkg != null && changingPkg.equals(bp.sourcePackage)) {
8165 if (pkgInfo == null || !hasPermission(pkgInfo, bp.name)) {
8166 Slog.i(TAG, "Removing old permission tree: " + bp.name
8167 + " from package " + bp.sourcePackage);
8168 flags |= UPDATE_PERMISSIONS_ALL;
8174 // Make sure all dynamic permissions have been assigned to a package,
8175 // and make sure there are no dangling permissions.
8176 it = mSettings.mPermissions.values().iterator();
8177 while (it.hasNext()) {
8178 final BasePermission bp = it.next();
8179 if (bp.type == BasePermission.TYPE_DYNAMIC) {
8180 if (DEBUG_SETTINGS) Log.v(TAG, "Dynamic permission: name="
8181 + bp.name + " pkg=" + bp.sourcePackage
8182 + " info=" + bp.pendingInfo);
8183 if (bp.packageSetting == null && bp.pendingInfo != null) {
8184 final BasePermission tree = findPermissionTreeLP(bp.name);
8185 if (tree != null && tree.perm != null) {
8186 bp.packageSetting = tree.packageSetting;
8187 bp.perm = new PackageParser.Permission(tree.perm.owner,
8188 new PermissionInfo(bp.pendingInfo));
8189 bp.perm.info.packageName = tree.perm.info.packageName;
8190 bp.perm.info.name = bp.name;
8195 if (bp.packageSetting == null) {
8196 // We may not yet have parsed the package, so just see if
8197 // we still know about its settings.
8198 bp.packageSetting = mSettings.mPackages.get(bp.sourcePackage);
8200 if (bp.packageSetting == null) {
8201 Slog.w(TAG, "Removing dangling permission: " + bp.name
8202 + " from package " + bp.sourcePackage);
8204 } else if (changingPkg != null && changingPkg.equals(bp.sourcePackage)) {
8205 if (pkgInfo == null || !hasPermission(pkgInfo, bp.name)) {
8206 Slog.i(TAG, "Removing old permission: " + bp.name
8207 + " from package " + bp.sourcePackage);
8208 flags |= UPDATE_PERMISSIONS_ALL;
8214 // Now update the permissions for all packages, in particular
8215 // replace the granted permissions of the system packages.
8216 if ((flags&UPDATE_PERMISSIONS_ALL) != 0) {
8217 for (PackageParser.Package pkg : mPackages.values()) {
8218 if (pkg != pkgInfo) {
8219 grantPermissionsLPw(pkg, (flags&UPDATE_PERMISSIONS_REPLACE_ALL) != 0,
8225 if (pkgInfo != null) {
8226 grantPermissionsLPw(pkgInfo, (flags&UPDATE_PERMISSIONS_REPLACE_PKG) != 0, changingPkg);
8230 private void grantPermissionsLPw(PackageParser.Package pkg, boolean replace,
8231 String packageOfInterest) {
8232 // IMPORTANT: There are two types of permissions: install and runtime.
8233 // Install time permissions are granted when the app is installed to
8234 // all device users and users added in the future. Runtime permissions
8235 // are granted at runtime explicitly to specific users. Normal and signature
8236 // protected permissions are install time permissions. Dangerous permissions
8237 // are install permissions if the app's target SDK is Lollipop MR1 or older,
8238 // otherwise they are runtime permissions. This function does not manage
8239 // runtime permissions except for the case an app targeting Lollipop MR1
8240 // being upgraded to target a newer SDK, in which case dangerous permissions
8241 // are transformed from install time to runtime ones.
8243 final PackageSetting ps = (PackageSetting) pkg.mExtras;
8248 PermissionsState permissionsState = ps.getPermissionsState();
8249 PermissionsState origPermissions = permissionsState;
8251 final int[] currentUserIds = UserManagerService.getInstance().getUserIds();
8253 int[] changedRuntimePermissionUserIds = EMPTY_INT_ARRAY;
8255 boolean changedInstallPermission = false;
8258 ps.installPermissionsFixed = false;
8259 if (!ps.isSharedUser()) {
8260 origPermissions = new PermissionsState(permissionsState);
8261 permissionsState.reset();
8265 permissionsState.setGlobalGids(mGlobalGids);
8267 final int N = pkg.requestedPermissions.size();
8268 for (int i=0; i<N; i++) {
8269 final String name = pkg.requestedPermissions.get(i);
8270 final BasePermission bp = mSettings.mPermissions.get(name);
8272 if (DEBUG_INSTALL) {
8273 Log.i(TAG, "Package " + pkg.packageName + " checking " + name + ": " + bp);
8276 if (bp == null || bp.packageSetting == null) {
8277 if (packageOfInterest == null || packageOfInterest.equals(pkg.packageName)) {
8278 Slog.w(TAG, "Unknown permission " + name
8279 + " in package " + pkg.packageName);
8284 final String perm = bp.name;
8285 boolean allowedSig = false;
8286 int grant = GRANT_DENIED;
8288 // Keep track of app op permissions.
8289 if ((bp.protectionLevel & PermissionInfo.PROTECTION_FLAG_APPOP) != 0) {
8290 ArraySet<String> pkgs = mAppOpPermissionPackages.get(bp.name);
8292 pkgs = new ArraySet<>();
8293 mAppOpPermissionPackages.put(bp.name, pkgs);
8295 pkgs.add(pkg.packageName);
8298 final int level = bp.protectionLevel & PermissionInfo.PROTECTION_MASK_BASE;
8300 case PermissionInfo.PROTECTION_NORMAL: {
8301 // For all apps normal permissions are install time ones.
8302 grant = GRANT_INSTALL;
8305 case PermissionInfo.PROTECTION_DANGEROUS: {
8306 if (pkg.applicationInfo.targetSdkVersion <= Build.VERSION_CODES.LOLLIPOP_MR1) {
8307 // For legacy apps dangerous permissions are install time ones.
8308 grant = GRANT_INSTALL_LEGACY;
8309 } else if (origPermissions.hasInstallPermission(bp.name)) {
8310 // For legacy apps that became modern, install becomes runtime.
8311 grant = GRANT_UPGRADE;
8313 // For modern apps keep runtime permissions unchanged.
8314 grant = GRANT_RUNTIME;
8318 case PermissionInfo.PROTECTION_SIGNATURE: {
8319 // For all apps signature permissions are install time ones.
8320 allowedSig = grantSignaturePermission(perm, pkg, bp, origPermissions);
8322 grant = GRANT_INSTALL;
8327 if (DEBUG_INSTALL) {
8328 Log.i(TAG, "Package " + pkg.packageName + " granting " + perm);
8331 if (grant != GRANT_DENIED) {
8332 if (!isSystemApp(ps) && ps.installPermissionsFixed) {
8333 // If this is an existing, non-system package, then
8334 // we can't add any new permissions to it.
8335 if (!allowedSig && !origPermissions.hasInstallPermission(perm)) {
8336 // Except... if this is a permission that was added
8337 // to the platform (note: need to only do this when
8338 // updating the platform).
8339 if (!isNewPlatformPermissionForPackage(perm, pkg)) {
8340 grant = GRANT_DENIED;
8346 case GRANT_INSTALL: {
8347 // Revoke this as runtime permission to handle the case of
8348 // a runtime permission being downgraded to an install one.
8349 for (int userId : UserManagerService.getInstance().getUserIds()) {
8350 if (origPermissions.getRuntimePermissionState(
8351 bp.name, userId) != null) {
8352 // Revoke the runtime permission and clear the flags.
8353 origPermissions.revokeRuntimePermission(bp, userId);
8354 origPermissions.updatePermissionFlags(bp, userId,
8355 PackageManager.MASK_PERMISSION_FLAGS, 0);
8356 // If we revoked a permission permission, we have to write.
8357 changedRuntimePermissionUserIds = ArrayUtils.appendInt(
8358 changedRuntimePermissionUserIds, userId);
8361 // Grant an install permission.
8362 if (permissionsState.grantInstallPermission(bp) !=
8363 PermissionsState.PERMISSION_OPERATION_FAILURE) {
8364 changedInstallPermission = true;
8368 case GRANT_INSTALL_LEGACY: {
8369 // Grant an install permission.
8370 if (permissionsState.grantInstallPermission(bp) !=
8371 PermissionsState.PERMISSION_OPERATION_FAILURE) {
8372 changedInstallPermission = true;
8376 case GRANT_RUNTIME: {
8377 // Grant previously granted runtime permissions.
8378 for (int userId : UserManagerService.getInstance().getUserIds()) {
8379 PermissionState permissionState = origPermissions
8380 .getRuntimePermissionState(bp.name, userId);
8381 final int flags = permissionState != null
8382 ? permissionState.getFlags() : 0;
8383 if (origPermissions.hasRuntimePermission(bp.name, userId)) {
8384 if (permissionsState.grantRuntimePermission(bp, userId) ==
8385 PermissionsState.PERMISSION_OPERATION_FAILURE) {
8386 // If we cannot put the permission as it was, we have to write.
8387 changedRuntimePermissionUserIds = ArrayUtils.appendInt(
8388 changedRuntimePermissionUserIds, userId);
8391 // Propagate the permission flags.
8392 permissionsState.updatePermissionFlags(bp, userId, flags, flags);
8396 case GRANT_UPGRADE: {
8397 // Grant runtime permissions for a previously held install permission.
8398 PermissionState permissionState = origPermissions
8399 .getInstallPermissionState(bp.name);
8400 final int flags = permissionState != null ? permissionState.getFlags() : 0;
8402 if (origPermissions.revokeInstallPermission(bp)
8403 != PermissionsState.PERMISSION_OPERATION_FAILURE) {
8404 // We will be transferring the permission flags, so clear them.
8405 origPermissions.updatePermissionFlags(bp, UserHandle.USER_ALL,
8406 PackageManager.MASK_PERMISSION_FLAGS, 0);
8407 changedInstallPermission = true;
8410 // If the permission is not to be promoted to runtime we ignore it and
8411 // also its other flags as they are not applicable to install permissions.
8412 if ((flags & PackageManager.FLAG_PERMISSION_REVOKE_ON_UPGRADE) == 0) {
8413 for (int userId : currentUserIds) {
8414 if (permissionsState.grantRuntimePermission(bp, userId) !=
8415 PermissionsState.PERMISSION_OPERATION_FAILURE) {
8416 // Transfer the permission flags.
8417 permissionsState.updatePermissionFlags(bp, userId,
8419 // If we granted the permission, we have to write.
8420 changedRuntimePermissionUserIds = ArrayUtils.appendInt(
8421 changedRuntimePermissionUserIds, userId);
8428 if (packageOfInterest == null
8429 || packageOfInterest.equals(pkg.packageName)) {
8430 Slog.w(TAG, "Not granting permission " + perm
8431 + " to package " + pkg.packageName
8432 + " because it was previously installed without");
8437 if (permissionsState.revokeInstallPermission(bp) !=
8438 PermissionsState.PERMISSION_OPERATION_FAILURE) {
8439 // Also drop the permission flags.
8440 permissionsState.updatePermissionFlags(bp, UserHandle.USER_ALL,
8441 PackageManager.MASK_PERMISSION_FLAGS, 0);
8442 changedInstallPermission = true;
8443 Slog.i(TAG, "Un-granting permission " + perm
8444 + " from package " + pkg.packageName
8445 + " (protectionLevel=" + bp.protectionLevel
8446 + " flags=0x" + Integer.toHexString(pkg.applicationInfo.flags)
8448 } else if ((bp.protectionLevel&PermissionInfo.PROTECTION_FLAG_APPOP) == 0) {
8449 // Don't print warning for app op permissions, since it is fine for them
8450 // not to be granted, there is a UI for the user to decide.
8451 if (packageOfInterest == null || packageOfInterest.equals(pkg.packageName)) {
8452 Slog.w(TAG, "Not granting permission " + perm
8453 + " to package " + pkg.packageName
8454 + " (protectionLevel=" + bp.protectionLevel
8455 + " flags=0x" + Integer.toHexString(pkg.applicationInfo.flags)
8462 if ((changedInstallPermission || replace) && !ps.installPermissionsFixed &&
8463 !isSystemApp(ps) || isUpdatedSystemApp(ps)){
8464 // This is the first that we have heard about this package, so the
8465 // permissions we have now selected are fixed until explicitly
8467 ps.installPermissionsFixed = true;
8470 // Persist the runtime permissions state for users with changes.
8471 for (int userId : changedRuntimePermissionUserIds) {
8472 mSettings.writeRuntimePermissionsForUserLPr(userId, false);
8476 private boolean isNewPlatformPermissionForPackage(String perm, PackageParser.Package pkg) {
8477 boolean allowed = false;
8478 final int NP = PackageParser.NEW_PERMISSIONS.length;
8479 for (int ip=0; ip<NP; ip++) {
8480 final PackageParser.NewPermissionInfo npi
8481 = PackageParser.NEW_PERMISSIONS[ip];
8482 if (npi.name.equals(perm)
8483 && pkg.applicationInfo.targetSdkVersion < npi.sdkVersion) {
8485 Log.i(TAG, "Auto-granting " + perm + " to old pkg "
8493 private boolean grantSignaturePermission(String perm, PackageParser.Package pkg,
8494 BasePermission bp, PermissionsState origPermissions) {
8496 allowed = (compareSignatures(
8497 bp.packageSetting.signatures.mSignatures, pkg.mSignatures)
8498 == PackageManager.SIGNATURE_MATCH)
8499 || (compareSignatures(mPlatformPackage.mSignatures, pkg.mSignatures)
8500 == PackageManager.SIGNATURE_MATCH);
8501 if (!allowed && (bp.protectionLevel
8502 & PermissionInfo.PROTECTION_FLAG_PRIVILEGED) != 0) {
8503 if (isSystemApp(pkg)) {
8504 // For updated system applications, a system permission
8505 // is granted only if it had been defined by the original application.
8506 if (pkg.isUpdatedSystemApp()) {
8507 final PackageSetting sysPs = mSettings
8508 .getDisabledSystemPkgLPr(pkg.packageName);
8509 if (sysPs.getPermissionsState().hasInstallPermission(perm)) {
8510 // If the original was granted this permission, we take
8511 // that grant decision as read and propagate it to the
8513 if (sysPs.isPrivileged()) {
8517 // The system apk may have been updated with an older
8518 // version of the one on the data partition, but which
8519 // granted a new system permission that it didn't have
8520 // before. In this case we do want to allow the app to
8521 // now get the new permission if the ancestral apk is
8522 // privileged to get it.
8523 if (sysPs.pkg != null && sysPs.isPrivileged()) {
8525 j<sysPs.pkg.requestedPermissions.size(); j++) {
8527 sysPs.pkg.requestedPermissions.get(j))) {
8535 allowed = isPrivilegedApp(pkg);
8540 if (!allowed && (bp.protectionLevel
8541 & PermissionInfo.PROTECTION_FLAG_PRE23) != 0
8542 && pkg.applicationInfo.targetSdkVersion < Build.VERSION_CODES.MNC) {
8543 // If this was a previously normal/dangerous permission that got moved
8544 // to a system permission as part of the runtime permission redesign, then
8545 // we still want to blindly grant it to old apps.
8548 if (!allowed && (bp.protectionLevel & PermissionInfo.PROTECTION_FLAG_INSTALLER) != 0
8549 && pkg.packageName.equals(mRequiredInstallerPackage)) {
8550 // If this permission is to be granted to the system installer and
8551 // this app is an installer, then it gets the permission.
8554 if (!allowed && (bp.protectionLevel & PermissionInfo.PROTECTION_FLAG_VERIFIER) != 0
8555 && pkg.packageName.equals(mRequiredVerifierPackage)) {
8556 // If this permission is to be granted to the system verifier and
8557 // this app is a verifier, then it gets the permission.
8560 if (!allowed && (bp.protectionLevel
8561 & PermissionInfo.PROTECTION_FLAG_PREINSTALLED) != 0
8562 && isSystemApp(pkg)) {
8563 // Any pre-installed system app is allowed to get this permission.
8566 if (!allowed && (bp.protectionLevel
8567 & PermissionInfo.PROTECTION_FLAG_DEVELOPMENT) != 0) {
8568 // For development permissions, a development permission
8569 // is granted only if it was already granted.
8570 allowed = origPermissions.hasInstallPermission(perm);
8576 final class ActivityIntentResolver
8577 extends IntentResolver<PackageParser.ActivityIntentInfo, ResolveInfo> {
8578 public List<ResolveInfo> queryIntent(Intent intent, String resolvedType,
8579 boolean defaultOnly, int userId) {
8580 if (!sUserManager.exists(userId)) return null;
8581 mFlags = defaultOnly ? PackageManager.MATCH_DEFAULT_ONLY : 0;
8582 return super.queryIntent(intent, resolvedType, defaultOnly, userId);
8585 public List<ResolveInfo> queryIntent(Intent intent, String resolvedType, int flags,
8587 if (!sUserManager.exists(userId)) return null;
8589 return super.queryIntent(intent, resolvedType,
8590 (flags & PackageManager.MATCH_DEFAULT_ONLY) != 0, userId);
8593 public List<ResolveInfo> queryIntentForPackage(Intent intent, String resolvedType,
8594 int flags, ArrayList<PackageParser.Activity> packageActivities, int userId) {
8595 if (!sUserManager.exists(userId)) return null;
8596 if (packageActivities == null) {
8600 final boolean defaultOnly = (flags&PackageManager.MATCH_DEFAULT_ONLY) != 0;
8601 final int N = packageActivities.size();
8602 ArrayList<PackageParser.ActivityIntentInfo[]> listCut =
8603 new ArrayList<PackageParser.ActivityIntentInfo[]>(N);
8605 ArrayList<PackageParser.ActivityIntentInfo> intentFilters;
8606 for (int i = 0; i < N; ++i) {
8607 intentFilters = packageActivities.get(i).intents;
8608 if (intentFilters != null && intentFilters.size() > 0) {
8609 PackageParser.ActivityIntentInfo[] array =
8610 new PackageParser.ActivityIntentInfo[intentFilters.size()];
8611 intentFilters.toArray(array);
8615 return super.queryIntentFromList(intent, resolvedType, defaultOnly, listCut, userId);
8618 public final void addActivity(PackageParser.Activity a, String type) {
8619 final boolean systemApp = a.info.applicationInfo.isSystemApp();
8620 mActivities.put(a.getComponentName(), a);
8621 if (DEBUG_SHOW_INFO)
8623 TAG, " " + type + " " +
8624 (a.info.nonLocalizedLabel != null ? a.info.nonLocalizedLabel : a.info.name) + ":");
8625 if (DEBUG_SHOW_INFO)
8626 Log.v(TAG, " Class=" + a.info.name);
8627 final int NI = a.intents.size();
8628 for (int j=0; j<NI; j++) {
8629 PackageParser.ActivityIntentInfo intent = a.intents.get(j);
8630 if (!systemApp && intent.getPriority() > 0 && "activity".equals(type)) {
8631 intent.setPriority(0);
8632 Log.w(TAG, "Package " + a.info.applicationInfo.packageName + " has activity "
8633 + a.className + " with priority > 0, forcing to 0");
8635 if (DEBUG_SHOW_INFO) {
8636 Log.v(TAG, " IntentFilter:");
8637 intent.dump(new LogPrinter(Log.VERBOSE, TAG), " ");
8639 if (!intent.debugCheck()) {
8640 Log.w(TAG, "==> For Activity " + a.info.name);
8646 public final void removeActivity(PackageParser.Activity a, String type) {
8647 mActivities.remove(a.getComponentName());
8648 if (DEBUG_SHOW_INFO) {
8649 Log.v(TAG, " " + type + " "
8650 + (a.info.nonLocalizedLabel != null ? a.info.nonLocalizedLabel
8651 : a.info.name) + ":");
8652 Log.v(TAG, " Class=" + a.info.name);
8654 final int NI = a.intents.size();
8655 for (int j=0; j<NI; j++) {
8656 PackageParser.ActivityIntentInfo intent = a.intents.get(j);
8657 if (DEBUG_SHOW_INFO) {
8658 Log.v(TAG, " IntentFilter:");
8659 intent.dump(new LogPrinter(Log.VERBOSE, TAG), " ");
8661 removeFilter(intent);
8666 protected boolean allowFilterResult(
8667 PackageParser.ActivityIntentInfo filter, List<ResolveInfo> dest) {
8668 ActivityInfo filterAi = filter.activity.info;
8669 for (int i=dest.size()-1; i>=0; i--) {
8670 ActivityInfo destAi = dest.get(i).activityInfo;
8671 if (destAi.name == filterAi.name
8672 && destAi.packageName == filterAi.packageName) {
8680 protected ActivityIntentInfo[] newArray(int size) {
8681 return new ActivityIntentInfo[size];
8685 protected boolean isFilterStopped(PackageParser.ActivityIntentInfo filter, int userId) {
8686 if (!sUserManager.exists(userId)) return true;
8687 PackageParser.Package p = filter.activity.owner;
8689 PackageSetting ps = (PackageSetting)p.mExtras;
8691 // System apps are never considered stopped for purposes of
8692 // filtering, because there may be no way for the user to
8693 // actually re-launch them.
8694 return (ps.pkgFlags&ApplicationInfo.FLAG_SYSTEM) == 0
8695 && ps.getStopped(userId);
8702 protected boolean isPackageForFilter(String packageName,
8703 PackageParser.ActivityIntentInfo info) {
8704 return packageName.equals(info.activity.owner.packageName);
8708 protected ResolveInfo newResult(PackageParser.ActivityIntentInfo info,
8709 int match, int userId) {
8710 if (!sUserManager.exists(userId)) return null;
8711 if (!mSettings.isEnabledLPr(info.activity.info, mFlags, userId)) {
8714 final PackageParser.Activity activity = info.activity;
8715 if (mSafeMode && (activity.info.applicationInfo.flags
8716 &ApplicationInfo.FLAG_SYSTEM) == 0) {
8719 PackageSetting ps = (PackageSetting) activity.owner.mExtras;
8723 ActivityInfo ai = PackageParser.generateActivityInfo(activity, mFlags,
8724 ps.readUserState(userId), userId);
8728 final ResolveInfo res = new ResolveInfo();
8729 res.activityInfo = ai;
8730 if ((mFlags&PackageManager.GET_RESOLVED_FILTER) != 0) {
8734 res.handleAllWebDataURI = info.handleAllWebDataURI();
8736 res.priority = info.getPriority();
8737 res.preferredOrder = activity.owner.mPreferredOrder;
8738 //System.out.println("Result: " + res.activityInfo.className +
8739 // " = " + res.priority);
8741 res.isDefault = info.hasDefault;
8742 res.labelRes = info.labelRes;
8743 res.nonLocalizedLabel = info.nonLocalizedLabel;
8744 if (userNeedsBadging(userId)) {
8745 res.noResourceId = true;
8747 res.icon = info.icon;
8749 res.iconResourceId = info.icon;
8750 res.system = res.activityInfo.applicationInfo.isSystemApp();
8755 protected void sortResults(List<ResolveInfo> results) {
8756 Collections.sort(results, mResolvePrioritySorter);
8760 protected void dumpFilter(PrintWriter out, String prefix,
8761 PackageParser.ActivityIntentInfo filter) {
8762 out.print(prefix); out.print(
8763 Integer.toHexString(System.identityHashCode(filter.activity)));
8765 filter.activity.printComponentShortName(out);
8766 out.print(" filter ");
8767 out.println(Integer.toHexString(System.identityHashCode(filter)));
8771 protected Object filterToLabel(PackageParser.ActivityIntentInfo filter) {
8772 return filter.activity;
8775 protected void dumpFilterLabel(PrintWriter out, String prefix, Object label, int count) {
8776 PackageParser.Activity activity = (PackageParser.Activity)label;
8777 out.print(prefix); out.print(
8778 Integer.toHexString(System.identityHashCode(activity)));
8780 activity.printComponentShortName(out);
8782 out.print(" ("); out.print(count); out.print(" filters)");
8787 // List<ResolveInfo> filterEnabled(List<ResolveInfo> resolveInfoList) {
8788 // final Iterator<ResolveInfo> i = resolveInfoList.iterator();
8789 // final List<ResolveInfo> retList = Lists.newArrayList();
8790 // while (i.hasNext()) {
8791 // final ResolveInfo resolveInfo = i.next();
8792 // if (isEnabledLP(resolveInfo.activityInfo)) {
8793 // retList.add(resolveInfo);
8799 // Keys are String (activity class name), values are Activity.
8800 private final ArrayMap<ComponentName, PackageParser.Activity> mActivities
8801 = new ArrayMap<ComponentName, PackageParser.Activity>();
8805 private final class ServiceIntentResolver
8806 extends IntentResolver<PackageParser.ServiceIntentInfo, ResolveInfo> {
8807 public List<ResolveInfo> queryIntent(Intent intent, String resolvedType,
8808 boolean defaultOnly, int userId) {
8809 mFlags = defaultOnly ? PackageManager.MATCH_DEFAULT_ONLY : 0;
8810 return super.queryIntent(intent, resolvedType, defaultOnly, userId);
8813 public List<ResolveInfo> queryIntent(Intent intent, String resolvedType, int flags,
8815 if (!sUserManager.exists(userId)) return null;
8817 return super.queryIntent(intent, resolvedType,
8818 (flags & PackageManager.MATCH_DEFAULT_ONLY) != 0, userId);
8821 public List<ResolveInfo> queryIntentForPackage(Intent intent, String resolvedType,
8822 int flags, ArrayList<PackageParser.Service> packageServices, int userId) {
8823 if (!sUserManager.exists(userId)) return null;
8824 if (packageServices == null) {
8828 final boolean defaultOnly = (flags&PackageManager.MATCH_DEFAULT_ONLY) != 0;
8829 final int N = packageServices.size();
8830 ArrayList<PackageParser.ServiceIntentInfo[]> listCut =
8831 new ArrayList<PackageParser.ServiceIntentInfo[]>(N);
8833 ArrayList<PackageParser.ServiceIntentInfo> intentFilters;
8834 for (int i = 0; i < N; ++i) {
8835 intentFilters = packageServices.get(i).intents;
8836 if (intentFilters != null && intentFilters.size() > 0) {
8837 PackageParser.ServiceIntentInfo[] array =
8838 new PackageParser.ServiceIntentInfo[intentFilters.size()];
8839 intentFilters.toArray(array);
8843 return super.queryIntentFromList(intent, resolvedType, defaultOnly, listCut, userId);
8846 public final void addService(PackageParser.Service s) {
8847 mServices.put(s.getComponentName(), s);
8848 if (DEBUG_SHOW_INFO) {
8850 + (s.info.nonLocalizedLabel != null
8851 ? s.info.nonLocalizedLabel : s.info.name) + ":");
8852 Log.v(TAG, " Class=" + s.info.name);
8854 final int NI = s.intents.size();
8856 for (j=0; j<NI; j++) {
8857 PackageParser.ServiceIntentInfo intent = s.intents.get(j);
8858 if (DEBUG_SHOW_INFO) {
8859 Log.v(TAG, " IntentFilter:");
8860 intent.dump(new LogPrinter(Log.VERBOSE, TAG), " ");
8862 if (!intent.debugCheck()) {
8863 Log.w(TAG, "==> For Service " + s.info.name);
8869 public final void removeService(PackageParser.Service s) {
8870 mServices.remove(s.getComponentName());
8871 if (DEBUG_SHOW_INFO) {
8872 Log.v(TAG, " " + (s.info.nonLocalizedLabel != null
8873 ? s.info.nonLocalizedLabel : s.info.name) + ":");
8874 Log.v(TAG, " Class=" + s.info.name);
8876 final int NI = s.intents.size();
8878 for (j=0; j<NI; j++) {
8879 PackageParser.ServiceIntentInfo intent = s.intents.get(j);
8880 if (DEBUG_SHOW_INFO) {
8881 Log.v(TAG, " IntentFilter:");
8882 intent.dump(new LogPrinter(Log.VERBOSE, TAG), " ");
8884 removeFilter(intent);
8889 protected boolean allowFilterResult(
8890 PackageParser.ServiceIntentInfo filter, List<ResolveInfo> dest) {
8891 ServiceInfo filterSi = filter.service.info;
8892 for (int i=dest.size()-1; i>=0; i--) {
8893 ServiceInfo destAi = dest.get(i).serviceInfo;
8894 if (destAi.name == filterSi.name
8895 && destAi.packageName == filterSi.packageName) {
8903 protected PackageParser.ServiceIntentInfo[] newArray(int size) {
8904 return new PackageParser.ServiceIntentInfo[size];
8908 protected boolean isFilterStopped(PackageParser.ServiceIntentInfo filter, int userId) {
8909 if (!sUserManager.exists(userId)) return true;
8910 PackageParser.Package p = filter.service.owner;
8912 PackageSetting ps = (PackageSetting)p.mExtras;
8914 // System apps are never considered stopped for purposes of
8915 // filtering, because there may be no way for the user to
8916 // actually re-launch them.
8917 return (ps.pkgFlags & ApplicationInfo.FLAG_SYSTEM) == 0
8918 && ps.getStopped(userId);
8925 protected boolean isPackageForFilter(String packageName,
8926 PackageParser.ServiceIntentInfo info) {
8927 return packageName.equals(info.service.owner.packageName);
8931 protected ResolveInfo newResult(PackageParser.ServiceIntentInfo filter,
8932 int match, int userId) {
8933 if (!sUserManager.exists(userId)) return null;
8934 final PackageParser.ServiceIntentInfo info = (PackageParser.ServiceIntentInfo)filter;
8935 if (!mSettings.isEnabledLPr(info.service.info, mFlags, userId)) {
8938 final PackageParser.Service service = info.service;
8939 if (mSafeMode && (service.info.applicationInfo.flags
8940 &ApplicationInfo.FLAG_SYSTEM) == 0) {
8943 PackageSetting ps = (PackageSetting) service.owner.mExtras;
8947 ServiceInfo si = PackageParser.generateServiceInfo(service, mFlags,
8948 ps.readUserState(userId), userId);
8952 final ResolveInfo res = new ResolveInfo();
8953 res.serviceInfo = si;
8954 if ((mFlags&PackageManager.GET_RESOLVED_FILTER) != 0) {
8955 res.filter = filter;
8957 res.priority = info.getPriority();
8958 res.preferredOrder = service.owner.mPreferredOrder;
8960 res.isDefault = info.hasDefault;
8961 res.labelRes = info.labelRes;
8962 res.nonLocalizedLabel = info.nonLocalizedLabel;
8963 res.icon = info.icon;
8964 res.system = res.serviceInfo.applicationInfo.isSystemApp();
8969 protected void sortResults(List<ResolveInfo> results) {
8970 Collections.sort(results, mResolvePrioritySorter);
8974 protected void dumpFilter(PrintWriter out, String prefix,
8975 PackageParser.ServiceIntentInfo filter) {
8976 out.print(prefix); out.print(
8977 Integer.toHexString(System.identityHashCode(filter.service)));
8979 filter.service.printComponentShortName(out);
8980 out.print(" filter ");
8981 out.println(Integer.toHexString(System.identityHashCode(filter)));
8985 protected Object filterToLabel(PackageParser.ServiceIntentInfo filter) {
8986 return filter.service;
8989 protected void dumpFilterLabel(PrintWriter out, String prefix, Object label, int count) {
8990 PackageParser.Service service = (PackageParser.Service)label;
8991 out.print(prefix); out.print(
8992 Integer.toHexString(System.identityHashCode(service)));
8994 service.printComponentShortName(out);
8996 out.print(" ("); out.print(count); out.print(" filters)");
9001 // List<ResolveInfo> filterEnabled(List<ResolveInfo> resolveInfoList) {
9002 // final Iterator<ResolveInfo> i = resolveInfoList.iterator();
9003 // final List<ResolveInfo> retList = Lists.newArrayList();
9004 // while (i.hasNext()) {
9005 // final ResolveInfo resolveInfo = (ResolveInfo) i;
9006 // if (isEnabledLP(resolveInfo.serviceInfo)) {
9007 // retList.add(resolveInfo);
9013 // Keys are String (activity class name), values are Activity.
9014 private final ArrayMap<ComponentName, PackageParser.Service> mServices
9015 = new ArrayMap<ComponentName, PackageParser.Service>();
9019 private final class ProviderIntentResolver
9020 extends IntentResolver<PackageParser.ProviderIntentInfo, ResolveInfo> {
9021 public List<ResolveInfo> queryIntent(Intent intent, String resolvedType,
9022 boolean defaultOnly, int userId) {
9023 mFlags = defaultOnly ? PackageManager.MATCH_DEFAULT_ONLY : 0;
9024 return super.queryIntent(intent, resolvedType, defaultOnly, userId);
9027 public List<ResolveInfo> queryIntent(Intent intent, String resolvedType, int flags,
9029 if (!sUserManager.exists(userId))
9032 return super.queryIntent(intent, resolvedType,
9033 (flags & PackageManager.MATCH_DEFAULT_ONLY) != 0, userId);
9036 public List<ResolveInfo> queryIntentForPackage(Intent intent, String resolvedType,
9037 int flags, ArrayList<PackageParser.Provider> packageProviders, int userId) {
9038 if (!sUserManager.exists(userId))
9040 if (packageProviders == null) {
9044 final boolean defaultOnly = (flags & PackageManager.MATCH_DEFAULT_ONLY) != 0;
9045 final int N = packageProviders.size();
9046 ArrayList<PackageParser.ProviderIntentInfo[]> listCut =
9047 new ArrayList<PackageParser.ProviderIntentInfo[]>(N);
9049 ArrayList<PackageParser.ProviderIntentInfo> intentFilters;
9050 for (int i = 0; i < N; ++i) {
9051 intentFilters = packageProviders.get(i).intents;
9052 if (intentFilters != null && intentFilters.size() > 0) {
9053 PackageParser.ProviderIntentInfo[] array =
9054 new PackageParser.ProviderIntentInfo[intentFilters.size()];
9055 intentFilters.toArray(array);
9059 return super.queryIntentFromList(intent, resolvedType, defaultOnly, listCut, userId);
9062 public final void addProvider(PackageParser.Provider p) {
9063 if (mProviders.containsKey(p.getComponentName())) {
9064 Slog.w(TAG, "Provider " + p.getComponentName() + " already defined; ignoring");
9068 mProviders.put(p.getComponentName(), p);
9069 if (DEBUG_SHOW_INFO) {
9071 + (p.info.nonLocalizedLabel != null
9072 ? p.info.nonLocalizedLabel : p.info.name) + ":");
9073 Log.v(TAG, " Class=" + p.info.name);
9075 final int NI = p.intents.size();
9077 for (j = 0; j < NI; j++) {
9078 PackageParser.ProviderIntentInfo intent = p.intents.get(j);
9079 if (DEBUG_SHOW_INFO) {
9080 Log.v(TAG, " IntentFilter:");
9081 intent.dump(new LogPrinter(Log.VERBOSE, TAG), " ");
9083 if (!intent.debugCheck()) {
9084 Log.w(TAG, "==> For Provider " + p.info.name);
9090 public final void removeProvider(PackageParser.Provider p) {
9091 mProviders.remove(p.getComponentName());
9092 if (DEBUG_SHOW_INFO) {
9093 Log.v(TAG, " " + (p.info.nonLocalizedLabel != null
9094 ? p.info.nonLocalizedLabel : p.info.name) + ":");
9095 Log.v(TAG, " Class=" + p.info.name);
9097 final int NI = p.intents.size();
9099 for (j = 0; j < NI; j++) {
9100 PackageParser.ProviderIntentInfo intent = p.intents.get(j);
9101 if (DEBUG_SHOW_INFO) {
9102 Log.v(TAG, " IntentFilter:");
9103 intent.dump(new LogPrinter(Log.VERBOSE, TAG), " ");
9105 removeFilter(intent);
9110 protected boolean allowFilterResult(
9111 PackageParser.ProviderIntentInfo filter, List<ResolveInfo> dest) {
9112 ProviderInfo filterPi = filter.provider.info;
9113 for (int i = dest.size() - 1; i >= 0; i--) {
9114 ProviderInfo destPi = dest.get(i).providerInfo;
9115 if (destPi.name == filterPi.name
9116 && destPi.packageName == filterPi.packageName) {
9124 protected PackageParser.ProviderIntentInfo[] newArray(int size) {
9125 return new PackageParser.ProviderIntentInfo[size];
9129 protected boolean isFilterStopped(PackageParser.ProviderIntentInfo filter, int userId) {
9130 if (!sUserManager.exists(userId))
9132 PackageParser.Package p = filter.provider.owner;
9134 PackageSetting ps = (PackageSetting) p.mExtras;
9136 // System apps are never considered stopped for purposes of
9137 // filtering, because there may be no way for the user to
9138 // actually re-launch them.
9139 return (ps.pkgFlags & ApplicationInfo.FLAG_SYSTEM) == 0
9140 && ps.getStopped(userId);
9147 protected boolean isPackageForFilter(String packageName,
9148 PackageParser.ProviderIntentInfo info) {
9149 return packageName.equals(info.provider.owner.packageName);
9153 protected ResolveInfo newResult(PackageParser.ProviderIntentInfo filter,
9154 int match, int userId) {
9155 if (!sUserManager.exists(userId))
9157 final PackageParser.ProviderIntentInfo info = filter;
9158 if (!mSettings.isEnabledLPr(info.provider.info, mFlags, userId)) {
9161 final PackageParser.Provider provider = info.provider;
9162 if (mSafeMode && (provider.info.applicationInfo.flags
9163 & ApplicationInfo.FLAG_SYSTEM) == 0) {
9166 PackageSetting ps = (PackageSetting) provider.owner.mExtras;
9170 ProviderInfo pi = PackageParser.generateProviderInfo(provider, mFlags,
9171 ps.readUserState(userId), userId);
9175 final ResolveInfo res = new ResolveInfo();
9176 res.providerInfo = pi;
9177 if ((mFlags & PackageManager.GET_RESOLVED_FILTER) != 0) {
9178 res.filter = filter;
9180 res.priority = info.getPriority();
9181 res.preferredOrder = provider.owner.mPreferredOrder;
9183 res.isDefault = info.hasDefault;
9184 res.labelRes = info.labelRes;
9185 res.nonLocalizedLabel = info.nonLocalizedLabel;
9186 res.icon = info.icon;
9187 res.system = res.providerInfo.applicationInfo.isSystemApp();
9192 protected void sortResults(List<ResolveInfo> results) {
9193 Collections.sort(results, mResolvePrioritySorter);
9197 protected void dumpFilter(PrintWriter out, String prefix,
9198 PackageParser.ProviderIntentInfo filter) {
9201 Integer.toHexString(System.identityHashCode(filter.provider)));
9203 filter.provider.printComponentShortName(out);
9204 out.print(" filter ");
9205 out.println(Integer.toHexString(System.identityHashCode(filter)));
9209 protected Object filterToLabel(PackageParser.ProviderIntentInfo filter) {
9210 return filter.provider;
9213 protected void dumpFilterLabel(PrintWriter out, String prefix, Object label, int count) {
9214 PackageParser.Provider provider = (PackageParser.Provider)label;
9215 out.print(prefix); out.print(
9216 Integer.toHexString(System.identityHashCode(provider)));
9218 provider.printComponentShortName(out);
9220 out.print(" ("); out.print(count); out.print(" filters)");
9225 private final ArrayMap<ComponentName, PackageParser.Provider> mProviders
9226 = new ArrayMap<ComponentName, PackageParser.Provider>();
9230 private static final Comparator<ResolveInfo> mResolvePrioritySorter =
9231 new Comparator<ResolveInfo>() {
9232 public int compare(ResolveInfo r1, ResolveInfo r2) {
9233 int v1 = r1.priority;
9234 int v2 = r2.priority;
9235 //System.out.println("Comparing: q1=" + q1 + " q2=" + q2);
9237 return (v1 > v2) ? -1 : 1;
9239 v1 = r1.preferredOrder;
9240 v2 = r2.preferredOrder;
9242 return (v1 > v2) ? -1 : 1;
9244 if (r1.isDefault != r2.isDefault) {
9245 return r1.isDefault ? -1 : 1;
9249 //System.out.println("Comparing: m1=" + m1 + " m2=" + m2);
9251 return (v1 > v2) ? -1 : 1;
9253 if (r1.system != r2.system) {
9254 return r1.system ? -1 : 1;
9260 private static final Comparator<ProviderInfo> mProviderInitOrderSorter =
9261 new Comparator<ProviderInfo>() {
9262 public int compare(ProviderInfo p1, ProviderInfo p2) {
9263 final int v1 = p1.initOrder;
9264 final int v2 = p2.initOrder;
9265 return (v1 > v2) ? -1 : ((v1 < v2) ? 1 : 0);
9269 final void sendPackageBroadcast(final String action, final String pkg,
9270 final Bundle extras, final String targetPkg, final IIntentReceiver finishedReceiver,
9271 final int[] userIds) {
9272 mHandler.post(new Runnable() {
9276 final IActivityManager am = ActivityManagerNative.getDefault();
9277 if (am == null) return;
9278 final int[] resolvedUserIds;
9279 if (userIds == null) {
9280 resolvedUserIds = am.getRunningUserIds();
9282 resolvedUserIds = userIds;
9284 for (int id : resolvedUserIds) {
9285 final Intent intent = new Intent(action,
9286 pkg != null ? Uri.fromParts("package", pkg, null) : null);
9287 if (extras != null) {
9288 intent.putExtras(extras);
9290 if (targetPkg != null) {
9291 intent.setPackage(targetPkg);
9293 // Modify the UID when posting to other users
9294 int uid = intent.getIntExtra(Intent.EXTRA_UID, -1);
9295 if (uid > 0 && UserHandle.getUserId(uid) != id) {
9296 uid = UserHandle.getUid(id, UserHandle.getAppId(uid));
9297 intent.putExtra(Intent.EXTRA_UID, uid);
9299 intent.putExtra(Intent.EXTRA_USER_HANDLE, id);
9300 intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
9301 if (DEBUG_BROADCASTS) {
9302 RuntimeException here = new RuntimeException("here");
9303 here.fillInStackTrace();
9304 Slog.d(TAG, "Sending to user " + id + ": "
9305 + intent.toShortString(false, true, false, false)
9306 + " " + intent.getExtras(), here);
9308 am.broadcastIntent(null, intent, null, finishedReceiver,
9309 0, null, null, null, android.app.AppOpsManager.OP_NONE,
9310 null, finishedReceiver != null, false, id);
9312 } catch (RemoteException ex) {
9319 * Check if the external storage media is available. This is true if there
9320 * is a mounted external storage medium or if the external storage is
9323 private boolean isExternalMediaAvailable() {
9324 return mMediaMounted || Environment.isExternalStorageEmulated();
9328 public PackageCleanItem nextPackageToClean(PackageCleanItem lastPackage) {
9330 synchronized (mPackages) {
9331 if (!isExternalMediaAvailable()) {
9332 // If the external storage is no longer mounted at this point,
9333 // the caller may not have been able to delete all of this
9334 // packages files and can not delete any more. Bail.
9337 final ArrayList<PackageCleanItem> pkgs = mSettings.mPackagesToBeCleaned;
9338 if (lastPackage != null) {
9339 pkgs.remove(lastPackage);
9341 if (pkgs.size() > 0) {
9348 void schedulePackageCleaning(String packageName, int userId, boolean andCode) {
9349 final Message msg = mHandler.obtainMessage(START_CLEANING_PACKAGE,
9350 userId, andCode ? 1 : 0, packageName);
9354 if (mPostSystemReadyMessages == null) {
9355 mPostSystemReadyMessages = new ArrayList<>();
9357 mPostSystemReadyMessages.add(msg);
9361 void startCleaningPackages() {
9363 synchronized (mPackages) {
9364 if (!isExternalMediaAvailable()) {
9367 if (mSettings.mPackagesToBeCleaned.isEmpty()) {
9371 Intent intent = new Intent(PackageManager.ACTION_CLEAN_EXTERNAL_STORAGE);
9372 intent.setComponent(DEFAULT_CONTAINER_COMPONENT);
9373 IActivityManager am = ActivityManagerNative.getDefault();
9376 am.startService(null, intent, null, mContext.getOpPackageName(),
9377 UserHandle.USER_OWNER);
9378 } catch (RemoteException e) {
9384 public void installPackage(String originPath, IPackageInstallObserver2 observer,
9385 int installFlags, String installerPackageName, VerificationParams verificationParams,
9386 String packageAbiOverride) {
9387 installPackageAsUser(originPath, observer, installFlags, installerPackageName,
9388 verificationParams, packageAbiOverride, UserHandle.getCallingUserId());
9392 public void installPackageAsUser(String originPath, IPackageInstallObserver2 observer,
9393 int installFlags, String installerPackageName, VerificationParams verificationParams,
9394 String packageAbiOverride, int userId) {
9395 mContext.enforceCallingOrSelfPermission(android.Manifest.permission.INSTALL_PACKAGES, null);
9397 final int callingUid = Binder.getCallingUid();
9398 enforceCrossUserPermission(callingUid, userId, true, true, "installPackageAsUser");
9400 if (isUserRestricted(userId, UserManager.DISALLOW_INSTALL_APPS)) {
9402 if (observer != null) {
9403 observer.onPackageInstalled("", INSTALL_FAILED_USER_RESTRICTED, null, null);
9405 } catch (RemoteException re) {
9410 if ((callingUid == Process.SHELL_UID) || (callingUid == Process.ROOT_UID)) {
9411 installFlags |= PackageManager.INSTALL_FROM_ADB;
9414 // Caller holds INSTALL_PACKAGES permission, so we're less strict
9415 // about installerPackageName.
9417 installFlags &= ~PackageManager.INSTALL_FROM_ADB;
9418 installFlags &= ~PackageManager.INSTALL_ALL_USERS;
9422 if ((installFlags & PackageManager.INSTALL_ALL_USERS) != 0) {
9423 user = UserHandle.ALL;
9425 user = new UserHandle(userId);
9428 // Only system components can circumvent runtime permissions when installing.
9429 if ((installFlags & PackageManager.INSTALL_GRANT_RUNTIME_PERMISSIONS) != 0
9430 && mContext.checkCallingOrSelfPermission(Manifest.permission
9431 .INSTALL_GRANT_RUNTIME_PERMISSIONS) == PackageManager.PERMISSION_DENIED) {
9432 throw new SecurityException("You need the "
9433 + "android.permission.INSTALL_GRANT_RUNTIME_PERMISSIONS permission "
9434 + "to use the PackageManager.INSTALL_GRANT_RUNTIME_PERMISSIONS flag");
9437 verificationParams.setInstallerUid(callingUid);
9439 final File originFile = new File(originPath);
9440 final OriginInfo origin = OriginInfo.fromUntrustedFile(originFile);
9442 final Message msg = mHandler.obtainMessage(INIT_COPY);
9443 msg.obj = new InstallParams(origin, null, observer, installFlags, installerPackageName,
9444 null, verificationParams, user, packageAbiOverride);
9445 mHandler.sendMessage(msg);
9448 void installStage(String packageName, File stagedDir, String stagedCid,
9449 IPackageInstallObserver2 observer, PackageInstaller.SessionParams params,
9450 String installerPackageName, int installerUid, UserHandle user) {
9451 final VerificationParams verifParams = new VerificationParams(null, params.originatingUri,
9452 params.referrerUri, installerUid, null);
9453 verifParams.setInstallerUid(installerUid);
9455 final OriginInfo origin;
9456 if (stagedDir != null) {
9457 origin = OriginInfo.fromStagedFile(stagedDir);
9459 origin = OriginInfo.fromStagedContainer(stagedCid);
9462 final Message msg = mHandler.obtainMessage(INIT_COPY);
9463 msg.obj = new InstallParams(origin, null, observer, params.installFlags,
9464 installerPackageName, params.volumeUuid, verifParams, user, params.abiOverride);
9465 mHandler.sendMessage(msg);
9468 private void sendPackageAddedForUser(String packageName, PackageSetting pkgSetting, int userId) {
9469 Bundle extras = new Bundle(1);
9470 extras.putInt(Intent.EXTRA_UID, UserHandle.getUid(userId, pkgSetting.appId));
9472 sendPackageBroadcast(Intent.ACTION_PACKAGE_ADDED,
9473 packageName, extras, null, null, new int[] {userId});
9475 IActivityManager am = ActivityManagerNative.getDefault();
9476 final boolean isSystem =
9477 isSystemApp(pkgSetting) || isUpdatedSystemApp(pkgSetting);
9478 if (isSystem && am.isUserRunning(userId, false)) {
9479 // The just-installed/enabled app is bundled on the system, so presumed
9480 // to be able to run automatically without needing an explicit launch.
9481 // Send it a BOOT_COMPLETED if it would ordinarily have gotten one.
9482 Intent bcIntent = new Intent(Intent.ACTION_BOOT_COMPLETED)
9483 .addFlags(Intent.FLAG_INCLUDE_STOPPED_PACKAGES)
9484 .setPackage(packageName);
9485 am.broadcastIntent(null, bcIntent, null, null, 0, null, null, null,
9486 android.app.AppOpsManager.OP_NONE, null, false, false, userId);
9488 } catch (RemoteException e) {
9490 Slog.w(TAG, "Unable to bootstrap installed package", e);
9495 public boolean setApplicationHiddenSettingAsUser(String packageName, boolean hidden,
9497 mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MANAGE_USERS, null);
9498 PackageSetting pkgSetting;
9499 final int uid = Binder.getCallingUid();
9500 enforceCrossUserPermission(uid, userId, true, true,
9501 "setApplicationHiddenSetting for user " + userId);
9503 if (hidden && isPackageDeviceAdmin(packageName, userId)) {
9504 Slog.w(TAG, "Not hiding package " + packageName + ": has active device admin");
9508 long callingId = Binder.clearCallingIdentity();
9510 boolean sendAdded = false;
9511 boolean sendRemoved = false;
9513 synchronized (mPackages) {
9514 pkgSetting = mSettings.mPackages.get(packageName);
9515 if (pkgSetting == null) {
9518 if (pkgSetting.getHidden(userId) != hidden) {
9519 pkgSetting.setHidden(hidden, userId);
9520 mSettings.writePackageRestrictionsLPr(userId);
9529 sendPackageAddedForUser(packageName, pkgSetting, userId);
9533 killApplication(packageName, UserHandle.getUid(userId, pkgSetting.appId),
9535 sendApplicationHiddenForUser(packageName, pkgSetting, userId);
9538 Binder.restoreCallingIdentity(callingId);
9543 private void sendApplicationHiddenForUser(String packageName, PackageSetting pkgSetting,
9545 final PackageRemovedInfo info = new PackageRemovedInfo();
9546 info.removedPackage = packageName;
9547 info.removedUsers = new int[] {userId};
9548 info.uid = UserHandle.getUid(userId, pkgSetting.appId);
9549 info.sendBroadcast(false, false, false);
9553 * Returns true if application is not found or there was an error. Otherwise it returns
9554 * the hidden state of the package for the given user.
9557 public boolean getApplicationHiddenSettingAsUser(String packageName, int userId) {
9558 mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MANAGE_USERS, null);
9559 enforceCrossUserPermission(Binder.getCallingUid(), userId, true,
9560 false, "getApplicationHidden for user " + userId);
9561 PackageSetting pkgSetting;
9562 long callingId = Binder.clearCallingIdentity();
9565 synchronized (mPackages) {
9566 pkgSetting = mSettings.mPackages.get(packageName);
9567 if (pkgSetting == null) {
9570 return pkgSetting.getHidden(userId);
9573 Binder.restoreCallingIdentity(callingId);
9581 public int installExistingPackageAsUser(String packageName, int userId) {
9582 mContext.enforceCallingOrSelfPermission(android.Manifest.permission.INSTALL_PACKAGES,
9584 PackageSetting pkgSetting;
9585 final int uid = Binder.getCallingUid();
9586 enforceCrossUserPermission(uid, userId, true, true, "installExistingPackage for user "
9588 if (isUserRestricted(userId, UserManager.DISALLOW_INSTALL_APPS)) {
9589 return PackageManager.INSTALL_FAILED_USER_RESTRICTED;
9592 long callingId = Binder.clearCallingIdentity();
9594 boolean sendAdded = false;
9597 synchronized (mPackages) {
9598 pkgSetting = mSettings.mPackages.get(packageName);
9599 if (pkgSetting == null) {
9600 return PackageManager.INSTALL_FAILED_INVALID_URI;
9602 if (!pkgSetting.getInstalled(userId)) {
9603 pkgSetting.setInstalled(true, userId);
9604 pkgSetting.setHidden(false, userId);
9605 mSettings.writePackageRestrictionsLPr(userId);
9611 sendPackageAddedForUser(packageName, pkgSetting, userId);
9614 Binder.restoreCallingIdentity(callingId);
9617 return PackageManager.INSTALL_SUCCEEDED;
9620 boolean isUserRestricted(int userId, String restrictionKey) {
9621 Bundle restrictions = sUserManager.getUserRestrictions(userId);
9622 if (restrictions.getBoolean(restrictionKey, false)) {
9623 Log.w(TAG, "User is restricted: " + restrictionKey);
9630 public void verifyPendingInstall(int id, int verificationCode) throws RemoteException {
9631 mContext.enforceCallingOrSelfPermission(
9632 android.Manifest.permission.PACKAGE_VERIFICATION_AGENT,
9633 "Only package verification agents can verify applications");
9635 final Message msg = mHandler.obtainMessage(PACKAGE_VERIFIED);
9636 final PackageVerificationResponse response = new PackageVerificationResponse(
9637 verificationCode, Binder.getCallingUid());
9640 mHandler.sendMessage(msg);
9644 public void extendVerificationTimeout(int id, int verificationCodeAtTimeout,
9645 long millisecondsToDelay) {
9646 mContext.enforceCallingOrSelfPermission(
9647 android.Manifest.permission.PACKAGE_VERIFICATION_AGENT,
9648 "Only package verification agents can extend verification timeouts");
9650 final PackageVerificationState state = mPendingVerification.get(id);
9651 final PackageVerificationResponse response = new PackageVerificationResponse(
9652 verificationCodeAtTimeout, Binder.getCallingUid());
9654 if (millisecondsToDelay > PackageManager.MAXIMUM_VERIFICATION_TIMEOUT) {
9655 millisecondsToDelay = PackageManager.MAXIMUM_VERIFICATION_TIMEOUT;
9657 if (millisecondsToDelay < 0) {
9658 millisecondsToDelay = 0;
9660 if ((verificationCodeAtTimeout != PackageManager.VERIFICATION_ALLOW)
9661 && (verificationCodeAtTimeout != PackageManager.VERIFICATION_REJECT)) {
9662 verificationCodeAtTimeout = PackageManager.VERIFICATION_REJECT;
9665 if ((state != null) && !state.timeoutExtended()) {
9666 state.extendTimeout();
9668 final Message msg = mHandler.obtainMessage(PACKAGE_VERIFIED);
9671 mHandler.sendMessageDelayed(msg, millisecondsToDelay);
9675 private void broadcastPackageVerified(int verificationId, Uri packageUri,
9676 int verificationCode, UserHandle user) {
9677 final Intent intent = new Intent(Intent.ACTION_PACKAGE_VERIFIED);
9678 intent.setDataAndType(packageUri, PACKAGE_MIME_TYPE);
9679 intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
9680 intent.putExtra(PackageManager.EXTRA_VERIFICATION_ID, verificationId);
9681 intent.putExtra(PackageManager.EXTRA_VERIFICATION_RESULT, verificationCode);
9683 mContext.sendBroadcastAsUser(intent, user,
9684 android.Manifest.permission.PACKAGE_VERIFICATION_AGENT);
9687 private ComponentName matchComponentForVerifier(String packageName,
9688 List<ResolveInfo> receivers) {
9689 ActivityInfo targetReceiver = null;
9691 final int NR = receivers.size();
9692 for (int i = 0; i < NR; i++) {
9693 final ResolveInfo info = receivers.get(i);
9694 if (info.activityInfo == null) {
9698 if (packageName.equals(info.activityInfo.packageName)) {
9699 targetReceiver = info.activityInfo;
9704 if (targetReceiver == null) {
9708 return new ComponentName(targetReceiver.packageName, targetReceiver.name);
9711 private List<ComponentName> matchVerifiers(PackageInfoLite pkgInfo,
9712 List<ResolveInfo> receivers, final PackageVerificationState verificationState) {
9713 if (pkgInfo.verifiers.length == 0) {
9717 final int N = pkgInfo.verifiers.length;
9718 final List<ComponentName> sufficientVerifiers = new ArrayList<ComponentName>(N + 1);
9719 for (int i = 0; i < N; i++) {
9720 final VerifierInfo verifierInfo = pkgInfo.verifiers[i];
9722 final ComponentName comp = matchComponentForVerifier(verifierInfo.packageName,
9728 final int verifierUid = getUidForVerifier(verifierInfo);
9729 if (verifierUid == -1) {
9734 Slog.d(TAG, "Added sufficient verifier " + verifierInfo.packageName
9735 + " with the correct signature");
9737 sufficientVerifiers.add(comp);
9738 verificationState.addSufficientVerifier(verifierUid);
9741 return sufficientVerifiers;
9744 private int getUidForVerifier(VerifierInfo verifierInfo) {
9745 synchronized (mPackages) {
9746 final PackageParser.Package pkg = mPackages.get(verifierInfo.packageName);
9749 } else if (pkg.mSignatures.length != 1) {
9750 Slog.i(TAG, "Verifier package " + verifierInfo.packageName
9751 + " has more than one signature; ignoring");
9756 * If the public key of the package's signature does not match
9757 * our expected public key, then this is a different package and
9761 final byte[] expectedPublicKey;
9763 final Signature verifierSig = pkg.mSignatures[0];
9764 final PublicKey publicKey = verifierSig.getPublicKey();
9765 expectedPublicKey = publicKey.getEncoded();
9766 } catch (CertificateException e) {
9770 final byte[] actualPublicKey = verifierInfo.publicKey.getEncoded();
9772 if (!Arrays.equals(actualPublicKey, expectedPublicKey)) {
9773 Slog.i(TAG, "Verifier package " + verifierInfo.packageName
9774 + " does not have the expected public key; ignoring");
9778 return pkg.applicationInfo.uid;
9783 public void finishPackageInstall(int token) {
9784 enforceSystemOrRoot("Only the system is allowed to finish installs");
9786 if (DEBUG_INSTALL) {
9787 Slog.v(TAG, "BM finishing package install for " + token);
9790 final Message msg = mHandler.obtainMessage(POST_INSTALL, token, 0);
9791 mHandler.sendMessage(msg);
9795 * Get the verification agent timeout.
9797 * @return verification timeout in milliseconds
9799 private long getVerificationTimeout() {
9800 return android.provider.Settings.Global.getLong(mContext.getContentResolver(),
9801 android.provider.Settings.Global.PACKAGE_VERIFIER_TIMEOUT,
9802 DEFAULT_VERIFICATION_TIMEOUT);
9806 * Get the default verification agent response code.
9808 * @return default verification response code
9810 private int getDefaultVerificationResponse() {
9811 return android.provider.Settings.Global.getInt(mContext.getContentResolver(),
9812 android.provider.Settings.Global.PACKAGE_VERIFIER_DEFAULT_RESPONSE,
9813 DEFAULT_VERIFICATION_RESPONSE);
9817 * Check whether or not package verification has been enabled.
9819 * @return true if verification should be performed
9821 private boolean isVerificationEnabled(int userId, int installFlags) {
9822 if (!DEFAULT_VERIFY_ENABLE) {
9826 boolean ensureVerifyAppsEnabled = isUserRestricted(userId, UserManager.ENSURE_VERIFY_APPS);
9828 // Check if installing from ADB
9829 if ((installFlags & PackageManager.INSTALL_FROM_ADB) != 0) {
9830 // Do not run verification in a test harness environment
9831 if (ActivityManager.isRunningInTestHarness()) {
9834 if (ensureVerifyAppsEnabled) {
9837 // Check if the developer does not want package verification for ADB installs
9838 if (android.provider.Settings.Global.getInt(mContext.getContentResolver(),
9839 android.provider.Settings.Global.PACKAGE_VERIFIER_INCLUDE_ADB, 1) == 0) {
9844 if (ensureVerifyAppsEnabled) {
9848 return android.provider.Settings.Global.getInt(mContext.getContentResolver(),
9849 android.provider.Settings.Global.PACKAGE_VERIFIER_ENABLE, 1) == 1;
9853 public void verifyIntentFilter(int id, int verificationCode, List<String> failedDomains)
9854 throws RemoteException {
9855 mContext.enforceCallingOrSelfPermission(
9856 Manifest.permission.INTENT_FILTER_VERIFICATION_AGENT,
9857 "Only intentfilter verification agents can verify applications");
9859 final Message msg = mHandler.obtainMessage(INTENT_FILTER_VERIFIED);
9860 final IntentFilterVerificationResponse response = new IntentFilterVerificationResponse(
9861 Binder.getCallingUid(), verificationCode, failedDomains);
9864 mHandler.sendMessage(msg);
9868 public int getIntentVerificationStatus(String packageName, int userId) {
9869 synchronized (mPackages) {
9870 return mSettings.getIntentFilterVerificationStatusLPr(packageName, userId);
9875 public boolean updateIntentVerificationStatus(String packageName, int status, int userId) {
9876 mContext.enforceCallingOrSelfPermission(
9877 android.Manifest.permission.SET_PREFERRED_APPLICATIONS, null);
9879 boolean result = false;
9880 synchronized (mPackages) {
9881 result = mSettings.updateIntentFilterVerificationStatusLPw(packageName, status, userId);
9884 scheduleWritePackageRestrictionsLocked(userId);
9890 public List<IntentFilterVerificationInfo> getIntentFilterVerifications(String packageName) {
9891 synchronized (mPackages) {
9892 return mSettings.getIntentFilterVerificationsLPr(packageName);
9897 public List<IntentFilter> getAllIntentFilters(String packageName) {
9898 if (TextUtils.isEmpty(packageName)) {
9899 return Collections.<IntentFilter>emptyList();
9901 synchronized (mPackages) {
9902 PackageParser.Package pkg = mPackages.get(packageName);
9903 if (pkg == null || pkg.activities == null) {
9904 return Collections.<IntentFilter>emptyList();
9906 final int count = pkg.activities.size();
9907 ArrayList<IntentFilter> result = new ArrayList<>();
9908 for (int n=0; n<count; n++) {
9909 PackageParser.Activity activity = pkg.activities.get(n);
9910 if (activity.intents != null || activity.intents.size() > 0) {
9911 result.addAll(activity.intents);
9919 public boolean setDefaultBrowserPackageName(String packageName, int userId) {
9920 mContext.enforceCallingOrSelfPermission(
9921 android.Manifest.permission.SET_PREFERRED_APPLICATIONS, null);
9923 synchronized (mPackages) {
9924 boolean result = mSettings.setDefaultBrowserPackageNameLPw(packageName, userId);
9925 if (packageName != null) {
9926 result |= updateIntentVerificationStatus(packageName,
9927 PackageManager.INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_ALWAYS,
9928 UserHandle.myUserId());
9929 mDefaultPermissionPolicy.grantDefaultPermissionsToDefaultBrowserLPr(
9930 packageName, userId);
9937 public String getDefaultBrowserPackageName(int userId) {
9938 synchronized (mPackages) {
9939 return mSettings.getDefaultBrowserPackageNameLPw(userId);
9944 * Get the "allow unknown sources" setting.
9946 * @return the current "allow unknown sources" setting
9948 private int getUnknownSourcesSettings() {
9949 return android.provider.Settings.Global.getInt(mContext.getContentResolver(),
9950 android.provider.Settings.Global.INSTALL_NON_MARKET_APPS,
9955 public void setInstallerPackageName(String targetPackage, String installerPackageName) {
9956 final int uid = Binder.getCallingUid();
9958 synchronized (mPackages) {
9959 PackageSetting targetPackageSetting = mSettings.mPackages.get(targetPackage);
9960 if (targetPackageSetting == null) {
9961 throw new IllegalArgumentException("Unknown target package: " + targetPackage);
9964 PackageSetting installerPackageSetting;
9965 if (installerPackageName != null) {
9966 installerPackageSetting = mSettings.mPackages.get(installerPackageName);
9967 if (installerPackageSetting == null) {
9968 throw new IllegalArgumentException("Unknown installer package: "
9969 + installerPackageName);
9972 installerPackageSetting = null;
9975 Signature[] callerSignature;
9976 Object obj = mSettings.getUserIdLPr(uid);
9978 if (obj instanceof SharedUserSetting) {
9979 callerSignature = ((SharedUserSetting)obj).signatures.mSignatures;
9980 } else if (obj instanceof PackageSetting) {
9981 callerSignature = ((PackageSetting)obj).signatures.mSignatures;
9983 throw new SecurityException("Bad object " + obj + " for uid " + uid);
9986 throw new SecurityException("Unknown calling uid " + uid);
9989 // Verify: can't set installerPackageName to a package that is
9990 // not signed with the same cert as the caller.
9991 if (installerPackageSetting != null) {
9992 if (compareSignatures(callerSignature,
9993 installerPackageSetting.signatures.mSignatures)
9994 != PackageManager.SIGNATURE_MATCH) {
9995 throw new SecurityException(
9996 "Caller does not have same cert as new installer package "
9997 + installerPackageName);
10001 // Verify: if target already has an installer package, it must
10002 // be signed with the same cert as the caller.
10003 if (targetPackageSetting.installerPackageName != null) {
10004 PackageSetting setting = mSettings.mPackages.get(
10005 targetPackageSetting.installerPackageName);
10006 // If the currently set package isn't valid, then it's always
10007 // okay to change it.
10008 if (setting != null) {
10009 if (compareSignatures(callerSignature,
10010 setting.signatures.mSignatures)
10011 != PackageManager.SIGNATURE_MATCH) {
10012 throw new SecurityException(
10013 "Caller does not have same cert as old installer package "
10014 + targetPackageSetting.installerPackageName);
10020 targetPackageSetting.installerPackageName = installerPackageName;
10021 scheduleWriteSettingsLocked();
10025 private void processPendingInstall(final InstallArgs args, final int currentStatus) {
10026 // Queue up an async operation since the package installation may take a little while.
10027 mHandler.post(new Runnable() {
10028 public void run() {
10029 mHandler.removeCallbacks(this);
10030 // Result object to be returned
10031 PackageInstalledInfo res = new PackageInstalledInfo();
10032 res.returnCode = currentStatus;
10035 res.removedInfo = new PackageRemovedInfo();
10036 if (res.returnCode == PackageManager.INSTALL_SUCCEEDED) {
10037 args.doPreInstall(res.returnCode);
10038 synchronized (mInstallLock) {
10039 installPackageLI(args, res);
10041 args.doPostInstall(res.returnCode, res.uid);
10044 // A restore should be performed at this point if (a) the install
10045 // succeeded, (b) the operation is not an update, and (c) the new
10046 // package has not opted out of backup participation.
10047 final boolean update = res.removedInfo.removedPackage != null;
10048 final int flags = (res.pkg == null) ? 0 : res.pkg.applicationInfo.flags;
10049 boolean doRestore = !update
10050 && ((flags & ApplicationInfo.FLAG_ALLOW_BACKUP) != 0);
10052 // Set up the post-install work request bookkeeping. This will be used
10053 // and cleaned up by the post-install event handling regardless of whether
10054 // there's a restore pass performed. Token values are >= 1.
10056 if (mNextInstallToken < 0) mNextInstallToken = 1;
10057 token = mNextInstallToken++;
10059 PostInstallData data = new PostInstallData(args, res);
10060 mRunningInstalls.put(token, data);
10061 if (DEBUG_INSTALL) Log.v(TAG, "+ starting restore round-trip " + token);
10063 if (res.returnCode == PackageManager.INSTALL_SUCCEEDED && doRestore) {
10064 // Pass responsibility to the Backup Manager. It will perform a
10065 // restore if appropriate, then pass responsibility back to the
10066 // Package Manager to run the post-install observer callbacks
10068 IBackupManager bm = IBackupManager.Stub.asInterface(
10069 ServiceManager.getService(Context.BACKUP_SERVICE));
10071 if (DEBUG_INSTALL) Log.v(TAG, "token " + token
10072 + " to BM for possible restore");
10074 if (bm.isBackupServiceActive(UserHandle.USER_OWNER)) {
10075 bm.restoreAtInstall(res.pkg.applicationInfo.packageName, token);
10079 } catch (RemoteException e) {
10080 // can't happen; the backup manager is local
10081 } catch (Exception e) {
10082 Slog.e(TAG, "Exception trying to enqueue restore", e);
10086 Slog.e(TAG, "Backup Manager not found!");
10092 // No restore possible, or the Backup Manager was mysteriously not
10093 // available -- just fire the post-install work request directly.
10094 if (DEBUG_INSTALL) Log.v(TAG, "No restore - queue post-install for " + token);
10095 Message msg = mHandler.obtainMessage(POST_INSTALL, token, 0);
10096 mHandler.sendMessage(msg);
10102 private abstract class HandlerParams {
10103 private static final int MAX_RETRIES = 4;
10106 * Number of times startCopy() has been attempted and had a non-fatal
10109 private int mRetries = 0;
10111 /** User handle for the user requesting the information or installation. */
10112 private final UserHandle mUser;
10114 HandlerParams(UserHandle user) {
10118 UserHandle getUser() {
10122 final boolean startCopy() {
10125 if (DEBUG_INSTALL) Slog.i(TAG, "startCopy " + mUser + ": " + this);
10127 if (++mRetries > MAX_RETRIES) {
10128 Slog.w(TAG, "Failed to invoke remote methods on default container service. Giving up");
10129 mHandler.sendEmptyMessage(MCS_GIVE_UP);
10130 handleServiceError();
10136 } catch (RemoteException e) {
10137 if (DEBUG_INSTALL) Slog.i(TAG, "Posting install MCS_RECONNECT");
10138 mHandler.sendEmptyMessage(MCS_RECONNECT);
10141 handleReturnCode();
10145 final void serviceError() {
10146 if (DEBUG_INSTALL) Slog.i(TAG, "serviceError");
10147 handleServiceError();
10148 handleReturnCode();
10151 abstract void handleStartCopy() throws RemoteException;
10152 abstract void handleServiceError();
10153 abstract void handleReturnCode();
10156 class MeasureParams extends HandlerParams {
10157 private final PackageStats mStats;
10158 private boolean mSuccess;
10160 private final IPackageStatsObserver mObserver;
10162 public MeasureParams(PackageStats stats, IPackageStatsObserver observer) {
10163 super(new UserHandle(stats.userHandle));
10164 mObserver = observer;
10169 public String toString() {
10170 return "MeasureParams{"
10171 + Integer.toHexString(System.identityHashCode(this))
10172 + " " + mStats.packageName + "}";
10176 void handleStartCopy() throws RemoteException {
10177 synchronized (mInstallLock) {
10178 mSuccess = getPackageSizeInfoLI(mStats.packageName, mStats.userHandle, mStats);
10182 final boolean mounted;
10183 if (Environment.isExternalStorageEmulated()) {
10186 final String status = Environment.getExternalStorageState();
10187 mounted = (Environment.MEDIA_MOUNTED.equals(status)
10188 || Environment.MEDIA_MOUNTED_READ_ONLY.equals(status));
10192 final UserEnvironment userEnv = new UserEnvironment(mStats.userHandle);
10194 mStats.externalCacheSize = calculateDirectorySize(mContainerService,
10195 userEnv.buildExternalStorageAppCacheDirs(mStats.packageName));
10197 mStats.externalDataSize = calculateDirectorySize(mContainerService,
10198 userEnv.buildExternalStorageAppDataDirs(mStats.packageName));
10200 // Always subtract cache size, since it's a subdirectory
10201 mStats.externalDataSize -= mStats.externalCacheSize;
10203 mStats.externalMediaSize = calculateDirectorySize(mContainerService,
10204 userEnv.buildExternalStorageAppMediaDirs(mStats.packageName));
10206 mStats.externalObbSize = calculateDirectorySize(mContainerService,
10207 userEnv.buildExternalStorageAppObbDirs(mStats.packageName));
10213 void handleReturnCode() {
10214 if (mObserver != null) {
10216 mObserver.onGetStatsCompleted(mStats, mSuccess);
10217 } catch (RemoteException e) {
10218 Slog.i(TAG, "Observer no longer exists.");
10224 void handleServiceError() {
10225 Slog.e(TAG, "Could not measure application " + mStats.packageName
10226 + " external storage");
10230 private static long calculateDirectorySize(IMediaContainerService mcs, File[] paths)
10231 throws RemoteException {
10233 for (File path : paths) {
10234 result += mcs.calculateDirectorySize(path.getAbsolutePath());
10239 private static void clearDirectory(IMediaContainerService mcs, File[] paths) {
10240 for (File path : paths) {
10242 mcs.clearDirectory(path.getAbsolutePath());
10243 } catch (RemoteException e) {
10248 static class OriginInfo {
10250 * Location where install is coming from, before it has been
10251 * copied/renamed into place. This could be a single monolithic APK
10252 * file, or a cluster directory. This location may be untrusted.
10258 * Flag indicating that {@link #file} or {@link #cid} has already been
10259 * staged, meaning downstream users don't need to defensively copy the
10262 final boolean staged;
10265 * Flag indicating that {@link #file} or {@link #cid} is an already
10266 * installed app that is being moved.
10268 final boolean existing;
10270 final String resolvedPath;
10271 final File resolvedFile;
10273 static OriginInfo fromNothing() {
10274 return new OriginInfo(null, null, false, false);
10277 static OriginInfo fromUntrustedFile(File file) {
10278 return new OriginInfo(file, null, false, false);
10281 static OriginInfo fromExistingFile(File file) {
10282 return new OriginInfo(file, null, false, true);
10285 static OriginInfo fromStagedFile(File file) {
10286 return new OriginInfo(file, null, true, false);
10289 static OriginInfo fromStagedContainer(String cid) {
10290 return new OriginInfo(null, cid, true, false);
10293 private OriginInfo(File file, String cid, boolean staged, boolean existing) {
10296 this.staged = staged;
10297 this.existing = existing;
10300 resolvedPath = PackageHelper.getSdDir(cid);
10301 resolvedFile = new File(resolvedPath);
10302 } else if (file != null) {
10303 resolvedPath = file.getAbsolutePath();
10304 resolvedFile = file;
10306 resolvedPath = null;
10307 resolvedFile = null;
10314 final String fromUuid;
10315 final String toUuid;
10316 final String packageName;
10317 final String dataAppName;
10319 final String seinfo;
10321 public MoveInfo(int moveId, String fromUuid, String toUuid, String packageName,
10322 String dataAppName, int appId, String seinfo) {
10323 this.moveId = moveId;
10324 this.fromUuid = fromUuid;
10325 this.toUuid = toUuid;
10326 this.packageName = packageName;
10327 this.dataAppName = dataAppName;
10328 this.appId = appId;
10329 this.seinfo = seinfo;
10333 class InstallParams extends HandlerParams {
10334 final OriginInfo origin;
10335 final MoveInfo move;
10336 final IPackageInstallObserver2 observer;
10338 final String installerPackageName;
10339 final String volumeUuid;
10340 final VerificationParams verificationParams;
10341 private InstallArgs mArgs;
10343 final String packageAbiOverride;
10345 InstallParams(OriginInfo origin, MoveInfo move, IPackageInstallObserver2 observer,
10346 int installFlags, String installerPackageName, String volumeUuid,
10347 VerificationParams verificationParams, UserHandle user, String packageAbiOverride) {
10349 this.origin = origin;
10351 this.observer = observer;
10352 this.installFlags = installFlags;
10353 this.installerPackageName = installerPackageName;
10354 this.volumeUuid = volumeUuid;
10355 this.verificationParams = verificationParams;
10356 this.packageAbiOverride = packageAbiOverride;
10360 public String toString() {
10361 return "InstallParams{" + Integer.toHexString(System.identityHashCode(this))
10362 + " file=" + origin.file + " cid=" + origin.cid + "}";
10365 public ManifestDigest getManifestDigest() {
10366 if (verificationParams == null) {
10369 return verificationParams.getManifestDigest();
10372 private int installLocationPolicy(PackageInfoLite pkgLite) {
10373 String packageName = pkgLite.packageName;
10374 int installLocation = pkgLite.installLocation;
10375 boolean onSd = (installFlags & PackageManager.INSTALL_EXTERNAL) != 0;
10377 synchronized (mPackages) {
10378 PackageParser.Package pkg = mPackages.get(packageName);
10380 if ((installFlags & PackageManager.INSTALL_REPLACE_EXISTING) != 0) {
10381 // Check for downgrading.
10382 if ((installFlags & PackageManager.INSTALL_ALLOW_DOWNGRADE) == 0) {
10384 checkDowngrade(pkg, pkgLite);
10385 } catch (PackageManagerException e) {
10386 Slog.w(TAG, "Downgrade detected: " + e.getMessage());
10387 return PackageHelper.RECOMMEND_FAILED_VERSION_DOWNGRADE;
10390 // Check for updated system application.
10391 if ((pkg.applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM) != 0) {
10393 Slog.w(TAG, "Cannot install update to system app on sdcard");
10394 return PackageHelper.RECOMMEND_FAILED_INVALID_LOCATION;
10396 return PackageHelper.RECOMMEND_INSTALL_INTERNAL;
10399 // Install flag overrides everything.
10400 return PackageHelper.RECOMMEND_INSTALL_EXTERNAL;
10402 // If current upgrade specifies particular preference
10403 if (installLocation == PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY) {
10404 // Application explicitly specified internal.
10405 return PackageHelper.RECOMMEND_INSTALL_INTERNAL;
10406 } else if (installLocation == PackageInfo.INSTALL_LOCATION_PREFER_EXTERNAL) {
10407 // App explictly prefers external. Let policy decide
10409 // Prefer previous location
10410 if (isExternal(pkg)) {
10411 return PackageHelper.RECOMMEND_INSTALL_EXTERNAL;
10413 return PackageHelper.RECOMMEND_INSTALL_INTERNAL;
10417 // Invalid install. Return error code
10418 return PackageHelper.RECOMMEND_FAILED_ALREADY_EXISTS;
10422 // All the special cases have been taken care of.
10423 // Return result based on recommended install location.
10425 return PackageHelper.RECOMMEND_INSTALL_EXTERNAL;
10427 return pkgLite.recommendedInstallLocation;
10431 * Invoke remote method to get package information and install
10432 * location values. Override install location based on default
10433 * policy if needed and then create install arguments based
10434 * on the install location.
10436 public void handleStartCopy() throws RemoteException {
10437 int ret = PackageManager.INSTALL_SUCCEEDED;
10439 // If we're already staged, we've firmly committed to an install location
10440 if (origin.staged) {
10441 if (origin.file != null) {
10442 installFlags |= PackageManager.INSTALL_INTERNAL;
10443 installFlags &= ~PackageManager.INSTALL_EXTERNAL;
10444 } else if (origin.cid != null) {
10445 installFlags |= PackageManager.INSTALL_EXTERNAL;
10446 installFlags &= ~PackageManager.INSTALL_INTERNAL;
10448 throw new IllegalStateException("Invalid stage location");
10452 final boolean onSd = (installFlags & PackageManager.INSTALL_EXTERNAL) != 0;
10453 final boolean onInt = (installFlags & PackageManager.INSTALL_INTERNAL) != 0;
10455 PackageInfoLite pkgLite = null;
10457 if (onInt && onSd) {
10458 // Check if both bits are set.
10459 Slog.w(TAG, "Conflicting flags specified for installing on both internal and external");
10460 ret = PackageManager.INSTALL_FAILED_INVALID_INSTALL_LOCATION;
10462 pkgLite = mContainerService.getMinimalPackageInfo(origin.resolvedPath, installFlags,
10463 packageAbiOverride);
10466 * If we have too little free space, try to free cache
10467 * before giving up.
10469 if (!origin.staged && pkgLite.recommendedInstallLocation
10470 == PackageHelper.RECOMMEND_FAILED_INSUFFICIENT_STORAGE) {
10471 // TODO: focus freeing disk space on the target device
10472 final StorageManager storage = StorageManager.from(mContext);
10473 final long lowThreshold = storage.getStorageLowBytes(
10474 Environment.getDataDirectory());
10476 final long sizeBytes = mContainerService.calculateInstalledSize(
10477 origin.resolvedPath, isForwardLocked(), packageAbiOverride);
10479 if (mInstaller.freeCache(null, sizeBytes + lowThreshold) >= 0) {
10480 pkgLite = mContainerService.getMinimalPackageInfo(origin.resolvedPath,
10481 installFlags, packageAbiOverride);
10485 * The cache free must have deleted the file we
10486 * downloaded to install.
10488 * TODO: fix the "freeCache" call to not delete
10489 * the file we care about.
10491 if (pkgLite.recommendedInstallLocation
10492 == PackageHelper.RECOMMEND_FAILED_INVALID_URI) {
10493 pkgLite.recommendedInstallLocation
10494 = PackageHelper.RECOMMEND_FAILED_INSUFFICIENT_STORAGE;
10499 if (ret == PackageManager.INSTALL_SUCCEEDED) {
10500 int loc = pkgLite.recommendedInstallLocation;
10501 if (loc == PackageHelper.RECOMMEND_FAILED_INVALID_LOCATION) {
10502 ret = PackageManager.INSTALL_FAILED_INVALID_INSTALL_LOCATION;
10503 } else if (loc == PackageHelper.RECOMMEND_FAILED_ALREADY_EXISTS) {
10504 ret = PackageManager.INSTALL_FAILED_ALREADY_EXISTS;
10505 } else if (loc == PackageHelper.RECOMMEND_FAILED_INSUFFICIENT_STORAGE) {
10506 ret = PackageManager.INSTALL_FAILED_INSUFFICIENT_STORAGE;
10507 } else if (loc == PackageHelper.RECOMMEND_FAILED_INVALID_APK) {
10508 ret = PackageManager.INSTALL_FAILED_INVALID_APK;
10509 } else if (loc == PackageHelper.RECOMMEND_FAILED_INVALID_URI) {
10510 ret = PackageManager.INSTALL_FAILED_INVALID_URI;
10511 } else if (loc == PackageHelper.RECOMMEND_MEDIA_UNAVAILABLE) {
10512 ret = PackageManager.INSTALL_FAILED_MEDIA_UNAVAILABLE;
10514 // Override with defaults if needed.
10515 loc = installLocationPolicy(pkgLite);
10516 if (loc == PackageHelper.RECOMMEND_FAILED_VERSION_DOWNGRADE) {
10517 ret = PackageManager.INSTALL_FAILED_VERSION_DOWNGRADE;
10518 } else if (!onSd && !onInt) {
10519 // Override install location with flags
10520 if (loc == PackageHelper.RECOMMEND_INSTALL_EXTERNAL) {
10521 // Set the flag to install on external media.
10522 installFlags |= PackageManager.INSTALL_EXTERNAL;
10523 installFlags &= ~PackageManager.INSTALL_INTERNAL;
10525 // Make sure the flag for installing on external
10527 installFlags |= PackageManager.INSTALL_INTERNAL;
10528 installFlags &= ~PackageManager.INSTALL_EXTERNAL;
10534 final InstallArgs args = createInstallArgs(this);
10537 if (ret == PackageManager.INSTALL_SUCCEEDED) {
10539 * ADB installs appear as UserHandle.USER_ALL, and can only be performed by
10540 * UserHandle.USER_OWNER, so use the package verifier for UserHandle.USER_OWNER.
10542 int userIdentifier = getUser().getIdentifier();
10543 if (userIdentifier == UserHandle.USER_ALL
10544 && ((installFlags & PackageManager.INSTALL_FROM_ADB) != 0)) {
10545 userIdentifier = UserHandle.USER_OWNER;
10549 * Determine if we have any installed package verifiers. If we
10550 * do, then we'll defer to them to verify the packages.
10552 final int requiredUid = mRequiredVerifierPackage == null ? -1
10553 : getPackageUid(mRequiredVerifierPackage, userIdentifier);
10554 if (!origin.existing && requiredUid != -1
10555 && isVerificationEnabled(userIdentifier, installFlags)) {
10556 final Intent verification = new Intent(
10557 Intent.ACTION_PACKAGE_NEEDS_VERIFICATION);
10558 verification.addFlags(Intent.FLAG_RECEIVER_FOREGROUND);
10559 verification.setDataAndType(Uri.fromFile(new File(origin.resolvedPath)),
10560 PACKAGE_MIME_TYPE);
10561 verification.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
10563 final List<ResolveInfo> receivers = queryIntentReceivers(verification,
10564 PACKAGE_MIME_TYPE, PackageManager.GET_DISABLED_COMPONENTS,
10565 0 /* TODO: Which userId? */);
10567 if (DEBUG_VERIFY) {
10568 Slog.d(TAG, "Found " + receivers.size() + " verifiers for intent "
10569 + verification.toString() + " with " + pkgLite.verifiers.length
10570 + " optional verifiers");
10573 final int verificationId = mPendingVerificationToken++;
10575 verification.putExtra(PackageManager.EXTRA_VERIFICATION_ID, verificationId);
10577 verification.putExtra(PackageManager.EXTRA_VERIFICATION_INSTALLER_PACKAGE,
10578 installerPackageName);
10580 verification.putExtra(PackageManager.EXTRA_VERIFICATION_INSTALL_FLAGS,
10583 verification.putExtra(PackageManager.EXTRA_VERIFICATION_PACKAGE_NAME,
10584 pkgLite.packageName);
10586 verification.putExtra(PackageManager.EXTRA_VERIFICATION_VERSION_CODE,
10587 pkgLite.versionCode);
10589 if (verificationParams != null) {
10590 if (verificationParams.getVerificationURI() != null) {
10591 verification.putExtra(PackageManager.EXTRA_VERIFICATION_URI,
10592 verificationParams.getVerificationURI());
10594 if (verificationParams.getOriginatingURI() != null) {
10595 verification.putExtra(Intent.EXTRA_ORIGINATING_URI,
10596 verificationParams.getOriginatingURI());
10598 if (verificationParams.getReferrer() != null) {
10599 verification.putExtra(Intent.EXTRA_REFERRER,
10600 verificationParams.getReferrer());
10602 if (verificationParams.getOriginatingUid() >= 0) {
10603 verification.putExtra(Intent.EXTRA_ORIGINATING_UID,
10604 verificationParams.getOriginatingUid());
10606 if (verificationParams.getInstallerUid() >= 0) {
10607 verification.putExtra(PackageManager.EXTRA_VERIFICATION_INSTALLER_UID,
10608 verificationParams.getInstallerUid());
10612 final PackageVerificationState verificationState = new PackageVerificationState(
10613 requiredUid, args);
10615 mPendingVerification.append(verificationId, verificationState);
10617 final List<ComponentName> sufficientVerifiers = matchVerifiers(pkgLite,
10618 receivers, verificationState);
10621 * If any sufficient verifiers were listed in the package
10622 * manifest, attempt to ask them.
10624 if (sufficientVerifiers != null) {
10625 final int N = sufficientVerifiers.size();
10627 Slog.i(TAG, "Additional verifiers required, but none installed.");
10628 ret = PackageManager.INSTALL_FAILED_VERIFICATION_FAILURE;
10630 for (int i = 0; i < N; i++) {
10631 final ComponentName verifierComponent = sufficientVerifiers.get(i);
10633 final Intent sufficientIntent = new Intent(verification);
10634 sufficientIntent.setComponent(verifierComponent);
10636 mContext.sendBroadcastAsUser(sufficientIntent, getUser());
10641 final ComponentName requiredVerifierComponent = matchComponentForVerifier(
10642 mRequiredVerifierPackage, receivers);
10643 if (ret == PackageManager.INSTALL_SUCCEEDED
10644 && mRequiredVerifierPackage != null) {
10646 * Send the intent to the required verification agent,
10647 * but only start the verification timeout after the
10648 * target BroadcastReceivers have run.
10650 verification.setComponent(requiredVerifierComponent);
10651 mContext.sendOrderedBroadcastAsUser(verification, getUser(),
10652 android.Manifest.permission.PACKAGE_VERIFICATION_AGENT,
10653 new BroadcastReceiver() {
10655 public void onReceive(Context context, Intent intent) {
10656 final Message msg = mHandler
10657 .obtainMessage(CHECK_PENDING_VERIFICATION);
10658 msg.arg1 = verificationId;
10659 mHandler.sendMessageDelayed(msg, getVerificationTimeout());
10661 }, null, 0, null, null);
10664 * We don't want the copy to proceed until verification
10665 * succeeds, so null out this field.
10671 * No package verification is enabled, so immediately start
10672 * the remote call to initiate copy using temporary file.
10674 ret = args.copyApk(mContainerService, true);
10682 void handleReturnCode() {
10683 // If mArgs is null, then MCS couldn't be reached. When it
10684 // reconnects, it will try again to install. At that point, this
10686 if (mArgs != null) {
10687 processPendingInstall(mArgs, mRet);
10692 void handleServiceError() {
10693 mArgs = createInstallArgs(this);
10694 mRet = PackageManager.INSTALL_FAILED_INTERNAL_ERROR;
10697 public boolean isForwardLocked() {
10698 return (installFlags & PackageManager.INSTALL_FORWARD_LOCK) != 0;
10703 * Used during creation of InstallArgs
10705 * @param installFlags package installation flags
10706 * @return true if should be installed on external storage
10708 private static boolean installOnExternalAsec(int installFlags) {
10709 if ((installFlags & PackageManager.INSTALL_INTERNAL) != 0) {
10712 if ((installFlags & PackageManager.INSTALL_EXTERNAL) != 0) {
10719 * Used during creation of InstallArgs
10721 * @param installFlags package installation flags
10722 * @return true if should be installed as forward locked
10724 private static boolean installForwardLocked(int installFlags) {
10725 return (installFlags & PackageManager.INSTALL_FORWARD_LOCK) != 0;
10728 private InstallArgs createInstallArgs(InstallParams params) {
10729 if (params.move != null) {
10730 return new MoveInstallArgs(params);
10731 } else if (installOnExternalAsec(params.installFlags) || params.isForwardLocked()) {
10732 return new AsecInstallArgs(params);
10734 return new FileInstallArgs(params);
10739 * Create args that describe an existing installed package. Typically used
10740 * when cleaning up old installs, or used as a move source.
10742 private InstallArgs createInstallArgsForExisting(int installFlags, String codePath,
10743 String resourcePath, String[] instructionSets) {
10744 final boolean isInAsec;
10745 if (installOnExternalAsec(installFlags)) {
10746 /* Apps on SD card are always in ASEC containers. */
10748 } else if (installForwardLocked(installFlags)
10749 && !codePath.startsWith(mDrmAppPrivateInstallDir.getAbsolutePath())) {
10751 * Forward-locked apps are only in ASEC containers if they're the
10760 return new AsecInstallArgs(codePath, instructionSets,
10761 installOnExternalAsec(installFlags), installForwardLocked(installFlags));
10763 return new FileInstallArgs(codePath, resourcePath, instructionSets);
10767 static abstract class InstallArgs {
10768 /** @see InstallParams#origin */
10769 final OriginInfo origin;
10770 /** @see InstallParams#move */
10771 final MoveInfo move;
10773 final IPackageInstallObserver2 observer;
10774 // Always refers to PackageManager flags only
10775 final int installFlags;
10776 final String installerPackageName;
10777 final String volumeUuid;
10778 final ManifestDigest manifestDigest;
10779 final UserHandle user;
10780 final String abiOverride;
10782 // The list of instruction sets supported by this app. This is currently
10783 // only used during the rmdex() phase to clean up resources. We can get rid of this
10784 // if we move dex files under the common app path.
10785 /* nullable */ String[] instructionSets;
10787 InstallArgs(OriginInfo origin, MoveInfo move, IPackageInstallObserver2 observer,
10788 int installFlags, String installerPackageName, String volumeUuid,
10789 ManifestDigest manifestDigest, UserHandle user, String[] instructionSets,
10790 String abiOverride) {
10791 this.origin = origin;
10793 this.installFlags = installFlags;
10794 this.observer = observer;
10795 this.installerPackageName = installerPackageName;
10796 this.volumeUuid = volumeUuid;
10797 this.manifestDigest = manifestDigest;
10799 this.instructionSets = instructionSets;
10800 this.abiOverride = abiOverride;
10803 abstract int copyApk(IMediaContainerService imcs, boolean temp) throws RemoteException;
10804 abstract int doPreInstall(int status);
10807 * Rename package into final resting place. All paths on the given
10808 * scanned package should be updated to reflect the rename.
10810 abstract boolean doRename(int status, PackageParser.Package pkg, String oldCodePath);
10811 abstract int doPostInstall(int status, int uid);
10813 /** @see PackageSettingBase#codePathString */
10814 abstract String getCodePath();
10815 /** @see PackageSettingBase#resourcePathString */
10816 abstract String getResourcePath();
10818 // Need installer lock especially for dex file removal.
10819 abstract void cleanUpResourcesLI();
10820 abstract boolean doPostDeleteLI(boolean delete);
10823 * Called before the source arguments are copied. This is used mostly
10824 * for MoveParams when it needs to read the source file to put it in the
10828 return PackageManager.INSTALL_SUCCEEDED;
10832 * Called after the source arguments are copied. This is used mostly for
10833 * MoveParams when it needs to read the source file to put it in the
10838 int doPostCopy(int uid) {
10839 return PackageManager.INSTALL_SUCCEEDED;
10842 protected boolean isFwdLocked() {
10843 return (installFlags & PackageManager.INSTALL_FORWARD_LOCK) != 0;
10846 protected boolean isExternalAsec() {
10847 return (installFlags & PackageManager.INSTALL_EXTERNAL) != 0;
10850 UserHandle getUser() {
10855 private void removeDexFiles(List<String> allCodePaths, String[] instructionSets) {
10856 if (!allCodePaths.isEmpty()) {
10857 if (instructionSets == null) {
10858 throw new IllegalStateException("instructionSet == null");
10860 String[] dexCodeInstructionSets = getDexCodeInstructionSets(instructionSets);
10861 for (String codePath : allCodePaths) {
10862 for (String dexCodeInstructionSet : dexCodeInstructionSets) {
10863 int retCode = mInstaller.rmdex(codePath, dexCodeInstructionSet);
10865 Slog.w(TAG, "Couldn't remove dex file for package: "
10866 + " at location " + codePath + ", retcode=" + retCode);
10867 // we don't consider this to be a failure of the core package deletion
10875 * Logic to handle installation of non-ASEC applications, including copying
10876 * and renaming logic.
10878 class FileInstallArgs extends InstallArgs {
10879 private File codeFile;
10880 private File resourceFile;
10882 // Example topology:
10883 // /data/app/com.example/base.apk
10884 // /data/app/com.example/split_foo.apk
10885 // /data/app/com.example/lib/arm/libfoo.so
10886 // /data/app/com.example/lib/arm64/libfoo.so
10887 // /data/app/com.example/dalvik/arm/base.apk@classes.dex
10890 FileInstallArgs(InstallParams params) {
10891 super(params.origin, params.move, params.observer, params.installFlags,
10892 params.installerPackageName, params.volumeUuid, params.getManifestDigest(),
10893 params.getUser(), null /* instruction sets */, params.packageAbiOverride);
10894 if (isFwdLocked()) {
10895 throw new IllegalArgumentException("Forward locking only supported in ASEC");
10899 /** Existing install */
10900 FileInstallArgs(String codePath, String resourcePath, String[] instructionSets) {
10901 super(OriginInfo.fromNothing(), null, null, 0, null, null, null, null, instructionSets,
10903 this.codeFile = (codePath != null) ? new File(codePath) : null;
10904 this.resourceFile = (resourcePath != null) ? new File(resourcePath) : null;
10907 int copyApk(IMediaContainerService imcs, boolean temp) throws RemoteException {
10908 if (origin.staged) {
10909 if (DEBUG_INSTALL) Slog.d(TAG, origin.file + " already staged; skipping copy");
10910 codeFile = origin.file;
10911 resourceFile = origin.file;
10912 return PackageManager.INSTALL_SUCCEEDED;
10916 final File tempDir = mInstallerService.allocateStageDirLegacy(volumeUuid);
10917 codeFile = tempDir;
10918 resourceFile = tempDir;
10919 } catch (IOException e) {
10920 Slog.w(TAG, "Failed to create copy file: " + e);
10921 return PackageManager.INSTALL_FAILED_INSUFFICIENT_STORAGE;
10924 final IParcelFileDescriptorFactory target = new IParcelFileDescriptorFactory.Stub() {
10926 public ParcelFileDescriptor open(String name, int mode) throws RemoteException {
10927 if (!FileUtils.isValidExtFilename(name)) {
10928 throw new IllegalArgumentException("Invalid filename: " + name);
10931 final File file = new File(codeFile, name);
10932 final FileDescriptor fd = Os.open(file.getAbsolutePath(),
10933 O_RDWR | O_CREAT, 0644);
10934 Os.chmod(file.getAbsolutePath(), 0644);
10935 return new ParcelFileDescriptor(fd);
10936 } catch (ErrnoException e) {
10937 throw new RemoteException("Failed to open: " + e.getMessage());
10942 int ret = PackageManager.INSTALL_SUCCEEDED;
10943 ret = imcs.copyPackage(origin.file.getAbsolutePath(), target);
10944 if (ret != PackageManager.INSTALL_SUCCEEDED) {
10945 Slog.e(TAG, "Failed to copy package");
10949 final File libraryRoot = new File(codeFile, LIB_DIR_NAME);
10950 NativeLibraryHelper.Handle handle = null;
10952 handle = NativeLibraryHelper.Handle.create(codeFile);
10953 ret = NativeLibraryHelper.copyNativeBinariesWithOverride(handle, libraryRoot,
10955 } catch (IOException e) {
10956 Slog.e(TAG, "Copying native libraries failed", e);
10957 ret = PackageManager.INSTALL_FAILED_INTERNAL_ERROR;
10959 IoUtils.closeQuietly(handle);
10965 int doPreInstall(int status) {
10966 if (status != PackageManager.INSTALL_SUCCEEDED) {
10972 boolean doRename(int status, PackageParser.Package pkg, String oldCodePath) {
10973 if (status != PackageManager.INSTALL_SUCCEEDED) {
10978 final File targetDir = codeFile.getParentFile();
10979 final File beforeCodeFile = codeFile;
10980 final File afterCodeFile = getNextCodePath(targetDir, pkg.packageName);
10982 if (DEBUG_INSTALL) Slog.d(TAG, "Renaming " + beforeCodeFile + " to " + afterCodeFile);
10984 Os.rename(beforeCodeFile.getAbsolutePath(), afterCodeFile.getAbsolutePath());
10985 } catch (ErrnoException e) {
10986 Slog.w(TAG, "Failed to rename", e);
10990 if (!SELinux.restoreconRecursive(afterCodeFile)) {
10991 Slog.w(TAG, "Failed to restorecon");
10995 // Reflect the rename internally
10996 codeFile = afterCodeFile;
10997 resourceFile = afterCodeFile;
10999 // Reflect the rename in scanned details
11000 pkg.codePath = afterCodeFile.getAbsolutePath();
11001 pkg.baseCodePath = FileUtils.rewriteAfterRename(beforeCodeFile, afterCodeFile,
11003 pkg.splitCodePaths = FileUtils.rewriteAfterRename(beforeCodeFile, afterCodeFile,
11004 pkg.splitCodePaths);
11006 // Reflect the rename in app info
11007 pkg.applicationInfo.volumeUuid = pkg.volumeUuid;
11008 pkg.applicationInfo.setCodePath(pkg.codePath);
11009 pkg.applicationInfo.setBaseCodePath(pkg.baseCodePath);
11010 pkg.applicationInfo.setSplitCodePaths(pkg.splitCodePaths);
11011 pkg.applicationInfo.setResourcePath(pkg.codePath);
11012 pkg.applicationInfo.setBaseResourcePath(pkg.baseCodePath);
11013 pkg.applicationInfo.setSplitResourcePaths(pkg.splitCodePaths);
11018 int doPostInstall(int status, int uid) {
11019 if (status != PackageManager.INSTALL_SUCCEEDED) {
11026 String getCodePath() {
11027 return (codeFile != null) ? codeFile.getAbsolutePath() : null;
11031 String getResourcePath() {
11032 return (resourceFile != null) ? resourceFile.getAbsolutePath() : null;
11035 private boolean cleanUp() {
11036 if (codeFile == null || !codeFile.exists()) {
11040 if (codeFile.isDirectory()) {
11041 mInstaller.rmPackageDir(codeFile.getAbsolutePath());
11046 if (resourceFile != null && !FileUtils.contains(codeFile, resourceFile)) {
11047 resourceFile.delete();
11053 void cleanUpResourcesLI() {
11054 // Try enumerating all code paths before deleting
11055 List<String> allCodePaths = Collections.EMPTY_LIST;
11056 if (codeFile != null && codeFile.exists()) {
11058 final PackageLite pkg = PackageParser.parsePackageLite(codeFile, 0);
11059 allCodePaths = pkg.getAllCodePaths();
11060 } catch (PackageParserException e) {
11061 // Ignored; we tried our best
11066 removeDexFiles(allCodePaths, instructionSets);
11069 boolean doPostDeleteLI(boolean delete) {
11070 // XXX err, shouldn't we respect the delete flag?
11071 cleanUpResourcesLI();
11076 private boolean isAsecExternal(String cid) {
11077 final String asecPath = PackageHelper.getSdFilesystem(cid);
11078 return !asecPath.startsWith(mAsecInternalPath);
11081 private static void maybeThrowExceptionForMultiArchCopy(String message, int copyRet) throws
11082 PackageManagerException {
11084 if (copyRet != PackageManager.NO_NATIVE_LIBRARIES &&
11085 copyRet != PackageManager.INSTALL_FAILED_NO_MATCHING_ABIS) {
11086 throw new PackageManagerException(copyRet, message);
11092 * Extract the MountService "container ID" from the full code path of an
11095 static String cidFromCodePath(String fullCodePath) {
11096 int eidx = fullCodePath.lastIndexOf("/");
11097 String subStr1 = fullCodePath.substring(0, eidx);
11098 int sidx = subStr1.lastIndexOf("/");
11099 return subStr1.substring(sidx+1, eidx);
11103 * Logic to handle installation of ASEC applications, including copying and
11106 class AsecInstallArgs extends InstallArgs {
11107 static final String RES_FILE_NAME = "pkg.apk";
11108 static final String PUBLIC_RES_FILE_NAME = "res.zip";
11111 String packagePath;
11112 String resourcePath;
11115 AsecInstallArgs(InstallParams params) {
11116 super(params.origin, params.move, params.observer, params.installFlags,
11117 params.installerPackageName, params.volumeUuid, params.getManifestDigest(),
11118 params.getUser(), null /* instruction sets */, params.packageAbiOverride);
11121 /** Existing install */
11122 AsecInstallArgs(String fullCodePath, String[] instructionSets,
11123 boolean isExternal, boolean isForwardLocked) {
11124 super(OriginInfo.fromNothing(), null, null, (isExternal ? INSTALL_EXTERNAL : 0)
11125 | (isForwardLocked ? INSTALL_FORWARD_LOCK : 0), null, null, null, null,
11126 instructionSets, null);
11127 // Hackily pretend we're still looking at a full code path
11128 if (!fullCodePath.endsWith(RES_FILE_NAME)) {
11129 fullCodePath = new File(fullCodePath, RES_FILE_NAME).getAbsolutePath();
11132 // Extract cid from fullCodePath
11133 int eidx = fullCodePath.lastIndexOf("/");
11134 String subStr1 = fullCodePath.substring(0, eidx);
11135 int sidx = subStr1.lastIndexOf("/");
11136 cid = subStr1.substring(sidx+1, eidx);
11137 setMountPath(subStr1);
11140 AsecInstallArgs(String cid, String[] instructionSets, boolean isForwardLocked) {
11141 super(OriginInfo.fromNothing(), null, null, (isAsecExternal(cid) ? INSTALL_EXTERNAL : 0)
11142 | (isForwardLocked ? INSTALL_FORWARD_LOCK : 0), null, null, null, null,
11143 instructionSets, null);
11145 setMountPath(PackageHelper.getSdDir(cid));
11148 void createCopyFile() {
11149 cid = mInstallerService.allocateExternalStageCidLegacy();
11152 int copyApk(IMediaContainerService imcs, boolean temp) throws RemoteException {
11153 if (origin.staged) {
11154 if (DEBUG_INSTALL) Slog.d(TAG, origin.cid + " already staged; skipping copy");
11156 setMountPath(PackageHelper.getSdDir(cid));
11157 return PackageManager.INSTALL_SUCCEEDED;
11164 * Pre-emptively destroy the container since it's destroyed if
11165 * copying fails due to it existing anyway.
11167 PackageHelper.destroySdDir(cid);
11170 final String newMountPath = imcs.copyPackageToContainer(
11171 origin.file.getAbsolutePath(), cid, getEncryptKey(), isExternalAsec(),
11172 isFwdLocked(), deriveAbiOverride(abiOverride, null /* settings */));
11174 if (newMountPath != null) {
11175 setMountPath(newMountPath);
11176 return PackageManager.INSTALL_SUCCEEDED;
11178 return PackageManager.INSTALL_FAILED_CONTAINER_ERROR;
11183 String getCodePath() {
11184 return packagePath;
11188 String getResourcePath() {
11189 return resourcePath;
11192 int doPreInstall(int status) {
11193 if (status != PackageManager.INSTALL_SUCCEEDED) {
11194 // Destroy container
11195 PackageHelper.destroySdDir(cid);
11197 boolean mounted = PackageHelper.isContainerMounted(cid);
11199 String newMountPath = PackageHelper.mountSdDir(cid, getEncryptKey(),
11200 Process.SYSTEM_UID);
11201 if (newMountPath != null) {
11202 setMountPath(newMountPath);
11204 return PackageManager.INSTALL_FAILED_CONTAINER_ERROR;
11211 boolean doRename(int status, PackageParser.Package pkg, String oldCodePath) {
11212 String newCacheId = getNextCodePath(oldCodePath, pkg.packageName, "/" + RES_FILE_NAME);
11213 String newMountPath = null;
11214 if (PackageHelper.isContainerMounted(cid)) {
11215 // Unmount the container
11216 if (!PackageHelper.unMountSdDir(cid)) {
11217 Slog.i(TAG, "Failed to unmount " + cid + " before renaming");
11221 if (!PackageHelper.renameSdDir(cid, newCacheId)) {
11222 Slog.e(TAG, "Failed to rename " + cid + " to " + newCacheId +
11223 " which might be stale. Will try to clean up.");
11224 // Clean up the stale container and proceed to recreate.
11225 if (!PackageHelper.destroySdDir(newCacheId)) {
11226 Slog.e(TAG, "Very strange. Cannot clean up stale container " + newCacheId);
11229 // Successfully cleaned up stale container. Try to rename again.
11230 if (!PackageHelper.renameSdDir(cid, newCacheId)) {
11231 Slog.e(TAG, "Failed to rename " + cid + " to " + newCacheId
11232 + " inspite of cleaning it up.");
11236 if (!PackageHelper.isContainerMounted(newCacheId)) {
11237 Slog.w(TAG, "Mounting container " + newCacheId);
11238 newMountPath = PackageHelper.mountSdDir(newCacheId,
11239 getEncryptKey(), Process.SYSTEM_UID);
11241 newMountPath = PackageHelper.getSdDir(newCacheId);
11243 if (newMountPath == null) {
11244 Slog.w(TAG, "Failed to get cache path for " + newCacheId);
11247 Log.i(TAG, "Succesfully renamed " + cid +
11248 " to " + newCacheId +
11249 " at new path: " + newMountPath);
11252 final File beforeCodeFile = new File(packagePath);
11253 setMountPath(newMountPath);
11254 final File afterCodeFile = new File(packagePath);
11256 // Reflect the rename in scanned details
11257 pkg.codePath = afterCodeFile.getAbsolutePath();
11258 pkg.baseCodePath = FileUtils.rewriteAfterRename(beforeCodeFile, afterCodeFile,
11260 pkg.splitCodePaths = FileUtils.rewriteAfterRename(beforeCodeFile, afterCodeFile,
11261 pkg.splitCodePaths);
11263 // Reflect the rename in app info
11264 pkg.applicationInfo.volumeUuid = pkg.volumeUuid;
11265 pkg.applicationInfo.setCodePath(pkg.codePath);
11266 pkg.applicationInfo.setBaseCodePath(pkg.baseCodePath);
11267 pkg.applicationInfo.setSplitCodePaths(pkg.splitCodePaths);
11268 pkg.applicationInfo.setResourcePath(pkg.codePath);
11269 pkg.applicationInfo.setBaseResourcePath(pkg.baseCodePath);
11270 pkg.applicationInfo.setSplitResourcePaths(pkg.splitCodePaths);
11275 private void setMountPath(String mountPath) {
11276 final File mountFile = new File(mountPath);
11278 final File monolithicFile = new File(mountFile, RES_FILE_NAME);
11279 if (monolithicFile.exists()) {
11280 packagePath = monolithicFile.getAbsolutePath();
11281 if (isFwdLocked()) {
11282 resourcePath = new File(mountFile, PUBLIC_RES_FILE_NAME).getAbsolutePath();
11284 resourcePath = packagePath;
11287 packagePath = mountFile.getAbsolutePath();
11288 resourcePath = packagePath;
11292 int doPostInstall(int status, int uid) {
11293 if (status != PackageManager.INSTALL_SUCCEEDED) {
11296 final int groupOwner;
11297 final String protectedFile;
11298 if (isFwdLocked()) {
11299 groupOwner = UserHandle.getSharedAppGid(uid);
11300 protectedFile = RES_FILE_NAME;
11303 protectedFile = null;
11306 if (uid < Process.FIRST_APPLICATION_UID
11307 || !PackageHelper.fixSdPermissions(cid, groupOwner, protectedFile)) {
11308 Slog.e(TAG, "Failed to finalize " + cid);
11309 PackageHelper.destroySdDir(cid);
11310 return PackageManager.INSTALL_FAILED_CONTAINER_ERROR;
11313 boolean mounted = PackageHelper.isContainerMounted(cid);
11315 PackageHelper.mountSdDir(cid, getEncryptKey(), Process.myUid());
11321 private void cleanUp() {
11322 if (DEBUG_SD_INSTALL) Slog.i(TAG, "cleanUp");
11324 // Destroy secure container
11325 PackageHelper.destroySdDir(cid);
11328 private List<String> getAllCodePaths() {
11329 final File codeFile = new File(getCodePath());
11330 if (codeFile != null && codeFile.exists()) {
11332 final PackageLite pkg = PackageParser.parsePackageLite(codeFile, 0);
11333 return pkg.getAllCodePaths();
11334 } catch (PackageParserException e) {
11335 // Ignored; we tried our best
11338 return Collections.EMPTY_LIST;
11341 void cleanUpResourcesLI() {
11342 // Enumerate all code paths before deleting
11343 cleanUpResourcesLI(getAllCodePaths());
11346 private void cleanUpResourcesLI(List<String> allCodePaths) {
11348 removeDexFiles(allCodePaths, instructionSets);
11351 String getPackageName() {
11352 return getAsecPackageName(cid);
11355 boolean doPostDeleteLI(boolean delete) {
11356 if (DEBUG_SD_INSTALL) Slog.i(TAG, "doPostDeleteLI() del=" + delete);
11357 final List<String> allCodePaths = getAllCodePaths();
11358 boolean mounted = PackageHelper.isContainerMounted(cid);
11361 if (PackageHelper.unMountSdDir(cid)) {
11365 if (!mounted && delete) {
11366 cleanUpResourcesLI(allCodePaths);
11373 if (isFwdLocked()) {
11374 if (!PackageHelper.fixSdPermissions(cid,
11375 getPackageUid(DEFAULT_CONTAINER_PACKAGE, 0), RES_FILE_NAME)) {
11376 return PackageManager.INSTALL_FAILED_CONTAINER_ERROR;
11380 return PackageManager.INSTALL_SUCCEEDED;
11384 int doPostCopy(int uid) {
11385 if (isFwdLocked()) {
11386 if (uid < Process.FIRST_APPLICATION_UID
11387 || !PackageHelper.fixSdPermissions(cid, UserHandle.getSharedAppGid(uid),
11389 Slog.e(TAG, "Failed to finalize " + cid);
11390 PackageHelper.destroySdDir(cid);
11391 return PackageManager.INSTALL_FAILED_CONTAINER_ERROR;
11395 return PackageManager.INSTALL_SUCCEEDED;
11400 * Logic to handle movement of existing installed applications.
11402 class MoveInstallArgs extends InstallArgs {
11403 private File codeFile;
11404 private File resourceFile;
11407 MoveInstallArgs(InstallParams params) {
11408 super(params.origin, params.move, params.observer, params.installFlags,
11409 params.installerPackageName, params.volumeUuid, params.getManifestDigest(),
11410 params.getUser(), null /* instruction sets */, params.packageAbiOverride);
11413 int copyApk(IMediaContainerService imcs, boolean temp) {
11414 if (DEBUG_INSTALL) Slog.d(TAG, "Moving " + move.packageName + " from "
11415 + move.fromUuid + " to " + move.toUuid);
11416 synchronized (mInstaller) {
11417 if (mInstaller.copyCompleteApp(move.fromUuid, move.toUuid, move.packageName,
11418 move.dataAppName, move.appId, move.seinfo) != 0) {
11419 return PackageManager.INSTALL_FAILED_INTERNAL_ERROR;
11423 codeFile = new File(Environment.getDataAppDirectory(move.toUuid), move.dataAppName);
11424 resourceFile = codeFile;
11425 if (DEBUG_INSTALL) Slog.d(TAG, "codeFile after move is " + codeFile);
11427 return PackageManager.INSTALL_SUCCEEDED;
11430 int doPreInstall(int status) {
11431 if (status != PackageManager.INSTALL_SUCCEEDED) {
11432 cleanUp(move.toUuid);
11437 boolean doRename(int status, PackageParser.Package pkg, String oldCodePath) {
11438 if (status != PackageManager.INSTALL_SUCCEEDED) {
11439 cleanUp(move.toUuid);
11443 // Reflect the move in app info
11444 pkg.applicationInfo.volumeUuid = pkg.volumeUuid;
11445 pkg.applicationInfo.setCodePath(pkg.codePath);
11446 pkg.applicationInfo.setBaseCodePath(pkg.baseCodePath);
11447 pkg.applicationInfo.setSplitCodePaths(pkg.splitCodePaths);
11448 pkg.applicationInfo.setResourcePath(pkg.codePath);
11449 pkg.applicationInfo.setBaseResourcePath(pkg.baseCodePath);
11450 pkg.applicationInfo.setSplitResourcePaths(pkg.splitCodePaths);
11455 int doPostInstall(int status, int uid) {
11456 if (status == PackageManager.INSTALL_SUCCEEDED) {
11457 cleanUp(move.fromUuid);
11459 cleanUp(move.toUuid);
11465 String getCodePath() {
11466 return (codeFile != null) ? codeFile.getAbsolutePath() : null;
11470 String getResourcePath() {
11471 return (resourceFile != null) ? resourceFile.getAbsolutePath() : null;
11474 private boolean cleanUp(String volumeUuid) {
11475 final File codeFile = new File(Environment.getDataAppDirectory(volumeUuid),
11477 Slog.d(TAG, "Cleaning up " + move.packageName + " on " + volumeUuid);
11478 synchronized (mInstallLock) {
11479 // Clean up both app data and code
11480 removeDataDirsLI(volumeUuid, move.packageName);
11481 if (codeFile.isDirectory()) {
11482 mInstaller.rmPackageDir(codeFile.getAbsolutePath());
11490 void cleanUpResourcesLI() {
11491 throw new UnsupportedOperationException();
11494 boolean doPostDeleteLI(boolean delete) {
11495 throw new UnsupportedOperationException();
11499 static String getAsecPackageName(String packageCid) {
11500 int idx = packageCid.lastIndexOf("-");
11504 return packageCid.substring(0, idx);
11507 // Utility method used to create code paths based on package name and available index.
11508 private static String getNextCodePath(String oldCodePath, String prefix, String suffix) {
11509 String idxStr = "";
11511 // Fall back to default value of idx=1 if prefix is not
11512 // part of oldCodePath
11513 if (oldCodePath != null) {
11514 String subStr = oldCodePath;
11515 // Drop the suffix right away
11516 if (suffix != null && subStr.endsWith(suffix)) {
11517 subStr = subStr.substring(0, subStr.length() - suffix.length());
11519 // If oldCodePath already contains prefix find out the
11520 // ending index to either increment or decrement.
11521 int sidx = subStr.lastIndexOf(prefix);
11523 subStr = subStr.substring(sidx + prefix.length());
11524 if (subStr != null) {
11525 if (subStr.startsWith(INSTALL_PACKAGE_SUFFIX)) {
11526 subStr = subStr.substring(INSTALL_PACKAGE_SUFFIX.length());
11529 idx = Integer.parseInt(subStr);
11535 } catch(NumberFormatException e) {
11540 idxStr = INSTALL_PACKAGE_SUFFIX + Integer.toString(idx);
11541 return prefix + idxStr;
11544 private File getNextCodePath(File targetDir, String packageName) {
11548 result = new File(targetDir, packageName + "-" + suffix);
11550 } while (result.exists());
11554 // Utility method that returns the relative package path with respect
11555 // to the installation directory. Like say for /data/data/com.test-1.apk
11556 // string com.test-1 is returned.
11557 static String deriveCodePathName(String codePath) {
11558 if (codePath == null) {
11561 final File codeFile = new File(codePath);
11562 final String name = codeFile.getName();
11563 if (codeFile.isDirectory()) {
11565 } else if (name.endsWith(".apk") || name.endsWith(".tmp")) {
11566 final int lastDot = name.lastIndexOf('.');
11567 return name.substring(0, lastDot);
11569 Slog.w(TAG, "Odd, " + codePath + " doesn't look like an APK");
11574 class PackageInstalledInfo {
11577 // The set of users that originally had this package installed.
11579 // The set of users that now have this package installed.
11581 PackageParser.Package pkg;
11584 PackageRemovedInfo removedInfo;
11586 public void setError(int code, String msg) {
11592 public void setError(String msg, PackageParserException e) {
11593 returnCode = e.error;
11594 returnMsg = ExceptionUtils.getCompleteMessage(msg, e);
11595 Slog.w(TAG, msg, e);
11598 public void setError(String msg, PackageManagerException e) {
11599 returnCode = e.error;
11600 returnMsg = ExceptionUtils.getCompleteMessage(msg, e);
11601 Slog.w(TAG, msg, e);
11604 // In some error cases we want to convey more info back to the observer
11605 String origPackage;
11606 String origPermission;
11610 * Install a non-existing package.
11612 private void installNewPackageLI(PackageParser.Package pkg, int parseFlags, int scanFlags,
11613 UserHandle user, String installerPackageName, String volumeUuid,
11614 PackageInstalledInfo res) {
11615 // Remember this for later, in case we need to rollback this install
11616 String pkgName = pkg.packageName;
11618 if (DEBUG_INSTALL) Slog.d(TAG, "installNewPackageLI: " + pkg);
11619 final boolean dataDirExists = Environment
11620 .getDataUserPackageDirectory(volumeUuid, UserHandle.USER_OWNER, pkgName).exists();
11621 synchronized(mPackages) {
11622 if (mSettings.mRenamedPackages.containsKey(pkgName)) {
11623 // A package with the same name is already installed, though
11624 // it has been renamed to an older name. The package we
11625 // are trying to install should be installed as an update to
11626 // the existing one, but that has not been requested, so bail.
11627 res.setError(INSTALL_FAILED_ALREADY_EXISTS, "Attempt to re-install " + pkgName
11628 + " without first uninstalling package running as "
11629 + mSettings.mRenamedPackages.get(pkgName));
11632 if (mPackages.containsKey(pkgName)) {
11633 // Don't allow installation over an existing package with the same name.
11634 res.setError(INSTALL_FAILED_ALREADY_EXISTS, "Attempt to re-install " + pkgName
11635 + " without first uninstalling.");
11641 PackageParser.Package newPackage = scanPackageLI(pkg, parseFlags, scanFlags,
11642 System.currentTimeMillis(), user);
11644 updateSettingsLI(newPackage, installerPackageName, volumeUuid, null, null, res, user);
11645 // delete the partially installed application. the data directory will have to be
11646 // restored if it was already existing
11647 if (res.returnCode != PackageManager.INSTALL_SUCCEEDED) {
11648 // remove package from internal structures. Note that we want deletePackageX to
11649 // delete the package data and cache directories that it created in
11650 // scanPackageLocked, unless those directories existed before we even tried to
11652 deletePackageLI(pkgName, UserHandle.ALL, false, null, null,
11653 dataDirExists ? PackageManager.DELETE_KEEP_DATA : 0,
11654 res.removedInfo, true);
11657 } catch (PackageManagerException e) {
11658 res.setError("Package couldn't be installed in " + pkg.codePath, e);
11662 private boolean shouldCheckUpgradeKeySetLP(PackageSetting oldPs, int scanFlags) {
11663 // Can't rotate keys during boot or if sharedUser.
11664 if (oldPs == null || (scanFlags&SCAN_INITIAL) != 0 || oldPs.sharedUser != null
11665 || !oldPs.keySetData.isUsingUpgradeKeySets()) {
11668 // app is using upgradeKeySets; make sure all are valid
11669 KeySetManagerService ksms = mSettings.mKeySetManagerService;
11670 long[] upgradeKeySets = oldPs.keySetData.getUpgradeKeySets();
11671 for (int i = 0; i < upgradeKeySets.length; i++) {
11672 if (!ksms.isIdValidKeySetId(upgradeKeySets[i])) {
11673 Slog.wtf(TAG, "Package "
11674 + (oldPs.name != null ? oldPs.name : "<null>")
11675 + " contains upgrade-key-set reference to unknown key-set: "
11676 + upgradeKeySets[i]
11677 + " reverting to signatures check.");
11684 private boolean checkUpgradeKeySetLP(PackageSetting oldPS, PackageParser.Package newPkg) {
11685 // Upgrade keysets are being used. Determine if new package has a superset of the
11687 long[] upgradeKeySets = oldPS.keySetData.getUpgradeKeySets();
11688 KeySetManagerService ksms = mSettings.mKeySetManagerService;
11689 for (int i = 0; i < upgradeKeySets.length; i++) {
11690 Set<PublicKey> upgradeSet = ksms.getPublicKeysFromKeySetLPr(upgradeKeySets[i]);
11691 if (upgradeSet != null && newPkg.mSigningKeys.containsAll(upgradeSet)) {
11698 private void replacePackageLI(PackageParser.Package pkg, int parseFlags, int scanFlags,
11699 UserHandle user, String installerPackageName, String volumeUuid,
11700 PackageInstalledInfo res) {
11701 final PackageParser.Package oldPackage;
11702 final String pkgName = pkg.packageName;
11703 final int[] allUsers;
11704 final boolean[] perUserInstalled;
11705 final boolean weFroze;
11707 // First find the old package info and check signatures
11708 synchronized(mPackages) {
11709 oldPackage = mPackages.get(pkgName);
11710 if (DEBUG_INSTALL) Slog.d(TAG, "replacePackageLI: new=" + pkg + ", old=" + oldPackage);
11711 final PackageSetting ps = mSettings.mPackages.get(pkgName);
11712 if (shouldCheckUpgradeKeySetLP(ps, scanFlags)) {
11713 if(!checkUpgradeKeySetLP(ps, pkg)) {
11714 res.setError(INSTALL_FAILED_UPDATE_INCOMPATIBLE,
11715 "New package not signed by keys specified by upgrade-keysets: "
11720 // default to original signature matching
11721 if (compareSignatures(oldPackage.mSignatures, pkg.mSignatures)
11722 != PackageManager.SIGNATURE_MATCH) {
11723 res.setError(INSTALL_FAILED_UPDATE_INCOMPATIBLE,
11724 "New package has a different signature: " + pkgName);
11729 // In case of rollback, remember per-user/profile install state
11730 allUsers = sUserManager.getUserIds();
11731 perUserInstalled = new boolean[allUsers.length];
11732 for (int i = 0; i < allUsers.length; i++) {
11733 perUserInstalled[i] = ps != null ? ps.getInstalled(allUsers[i]) : false;
11736 // Mark the app as frozen to prevent launching during the upgrade
11737 // process, and then kill all running instances
11746 // Now that we're guarded by frozen state, kill app during upgrade
11747 killApplication(pkgName, oldPackage.applicationInfo.uid, "replace pkg");
11750 boolean sysPkg = (isSystemApp(oldPackage));
11752 replaceSystemPackageLI(oldPackage, pkg, parseFlags, scanFlags,
11753 user, allUsers, perUserInstalled, installerPackageName, volumeUuid, res);
11755 replaceNonSystemPackageLI(oldPackage, pkg, parseFlags, scanFlags,
11756 user, allUsers, perUserInstalled, installerPackageName, volumeUuid, res);
11759 // Regardless of success or failure of upgrade steps above, always
11760 // unfreeze the package if we froze it
11762 unfreezePackage(pkgName);
11767 private void replaceNonSystemPackageLI(PackageParser.Package deletedPackage,
11768 PackageParser.Package pkg, int parseFlags, int scanFlags, UserHandle user,
11769 int[] allUsers, boolean[] perUserInstalled, String installerPackageName,
11770 String volumeUuid, PackageInstalledInfo res) {
11771 String pkgName = deletedPackage.packageName;
11772 boolean deletedPkg = true;
11773 boolean updatedSettings = false;
11775 if (DEBUG_INSTALL) Slog.d(TAG, "replaceNonSystemPackageLI: new=" + pkg + ", old="
11777 long origUpdateTime;
11778 if (pkg.mExtras != null) {
11779 origUpdateTime = ((PackageSetting)pkg.mExtras).lastUpdateTime;
11781 origUpdateTime = 0;
11784 // First delete the existing package while retaining the data directory
11785 if (!deletePackageLI(pkgName, null, true, null, null, PackageManager.DELETE_KEEP_DATA,
11786 res.removedInfo, true)) {
11787 // If the existing package wasn't successfully deleted
11788 res.setError(INSTALL_FAILED_REPLACE_COULDNT_DELETE, "replaceNonSystemPackageLI");
11789 deletedPkg = false;
11791 // Successfully deleted the old package; proceed with replace.
11793 // If deleted package lived in a container, give users a chance to
11794 // relinquish resources before killing.
11795 if (deletedPackage.isForwardLocked() || isExternal(deletedPackage)) {
11796 if (DEBUG_INSTALL) {
11797 Slog.i(TAG, "upgrading pkg " + deletedPackage + " is ASEC-hosted -> UNAVAILABLE");
11799 final int[] uidArray = new int[] { deletedPackage.applicationInfo.uid };
11800 final ArrayList<String> pkgList = new ArrayList<String>(1);
11801 pkgList.add(deletedPackage.applicationInfo.packageName);
11802 sendResourcesChangedBroadcast(false, true, pkgList, uidArray, null);
11805 deleteCodeCacheDirsLI(pkg.volumeUuid, pkgName);
11807 final PackageParser.Package newPackage = scanPackageLI(pkg, parseFlags,
11808 scanFlags | SCAN_UPDATE_TIME, System.currentTimeMillis(), user);
11809 updateSettingsLI(newPackage, installerPackageName, volumeUuid, allUsers,
11810 perUserInstalled, res, user);
11811 updatedSettings = true;
11812 } catch (PackageManagerException e) {
11813 res.setError("Package couldn't be installed in " + pkg.codePath, e);
11817 if (res.returnCode != PackageManager.INSTALL_SUCCEEDED) {
11818 // remove package from internal structures. Note that we want deletePackageX to
11819 // delete the package data and cache directories that it created in
11820 // scanPackageLocked, unless those directories existed before we even tried to
11822 if(updatedSettings) {
11823 if (DEBUG_INSTALL) Slog.d(TAG, "Install failed, rolling pack: " + pkgName);
11825 pkgName, null, true, allUsers, perUserInstalled,
11826 PackageManager.DELETE_KEEP_DATA,
11827 res.removedInfo, true);
11829 // Since we failed to install the new package we need to restore the old
11830 // package that we deleted.
11832 if (DEBUG_INSTALL) Slog.d(TAG, "Install failed, reinstalling: " + deletedPackage);
11833 File restoreFile = new File(deletedPackage.codePath);
11834 // Parse old package
11835 boolean oldExternal = isExternal(deletedPackage);
11836 int oldParseFlags = mDefParseFlags | PackageParser.PARSE_CHATTY |
11837 (deletedPackage.isForwardLocked() ? PackageParser.PARSE_FORWARD_LOCK : 0) |
11838 (oldExternal ? PackageParser.PARSE_EXTERNAL_STORAGE : 0);
11839 int oldScanFlags = SCAN_UPDATE_SIGNATURE | SCAN_UPDATE_TIME;
11841 scanPackageLI(restoreFile, oldParseFlags, oldScanFlags, origUpdateTime, null);
11842 } catch (PackageManagerException e) {
11843 Slog.e(TAG, "Failed to restore package : " + pkgName + " after failed upgrade: "
11847 // Restore of old package succeeded. Update permissions.
11849 synchronized (mPackages) {
11850 updatePermissionsLPw(deletedPackage.packageName, deletedPackage,
11851 UPDATE_PERMISSIONS_ALL);
11852 // can downgrade to reader
11853 mSettings.writeLPr();
11855 Slog.i(TAG, "Successfully restored package : " + pkgName + " after failed upgrade");
11860 private void replaceSystemPackageLI(PackageParser.Package deletedPackage,
11861 PackageParser.Package pkg, int parseFlags, int scanFlags, UserHandle user,
11862 int[] allUsers, boolean[] perUserInstalled, String installerPackageName,
11863 String volumeUuid, PackageInstalledInfo res) {
11864 if (DEBUG_INSTALL) Slog.d(TAG, "replaceSystemPackageLI: new=" + pkg
11865 + ", old=" + deletedPackage);
11866 boolean disabledSystem = false;
11867 boolean updatedSettings = false;
11868 parseFlags |= PackageParser.PARSE_IS_SYSTEM;
11869 if ((deletedPackage.applicationInfo.privateFlags&ApplicationInfo.PRIVATE_FLAG_PRIVILEGED)
11871 parseFlags |= PackageParser.PARSE_IS_PRIVILEGED;
11873 String packageName = deletedPackage.packageName;
11874 if (packageName == null) {
11875 res.setError(INSTALL_FAILED_REPLACE_COULDNT_DELETE,
11876 "Attempt to delete null packageName.");
11879 PackageParser.Package oldPkg;
11880 PackageSetting oldPkgSetting;
11882 synchronized (mPackages) {
11883 oldPkg = mPackages.get(packageName);
11884 oldPkgSetting = mSettings.mPackages.get(packageName);
11885 if((oldPkg == null) || (oldPkg.applicationInfo == null) ||
11886 (oldPkgSetting == null)) {
11887 res.setError(INSTALL_FAILED_REPLACE_COULDNT_DELETE,
11888 "Couldn't find package:" + packageName + " information");
11893 res.removedInfo.uid = oldPkg.applicationInfo.uid;
11894 res.removedInfo.removedPackage = packageName;
11895 // Remove existing system package
11896 removePackageLI(oldPkgSetting, true);
11898 synchronized (mPackages) {
11899 disabledSystem = mSettings.disableSystemPackageLPw(packageName);
11900 if (!disabledSystem && deletedPackage != null) {
11901 // We didn't need to disable the .apk as a current system package,
11902 // which means we are replacing another update that is already
11903 // installed. We need to make sure to delete the older one's .apk.
11904 res.removedInfo.args = createInstallArgsForExisting(0,
11905 deletedPackage.applicationInfo.getCodePath(),
11906 deletedPackage.applicationInfo.getResourcePath(),
11907 getAppDexInstructionSets(deletedPackage.applicationInfo));
11909 res.removedInfo.args = null;
11913 // Successfully disabled the old package. Now proceed with re-installation
11914 deleteCodeCacheDirsLI(pkg.volumeUuid, packageName);
11916 res.returnCode = PackageManager.INSTALL_SUCCEEDED;
11917 pkg.applicationInfo.flags |= ApplicationInfo.FLAG_UPDATED_SYSTEM_APP;
11919 PackageParser.Package newPackage = null;
11921 newPackage = scanPackageLI(pkg, parseFlags, scanFlags, 0, user);
11922 if (newPackage.mExtras != null) {
11923 final PackageSetting newPkgSetting = (PackageSetting) newPackage.mExtras;
11924 newPkgSetting.firstInstallTime = oldPkgSetting.firstInstallTime;
11925 newPkgSetting.lastUpdateTime = System.currentTimeMillis();
11927 // is the update attempting to change shared user? that isn't going to work...
11928 if (oldPkgSetting.sharedUser != newPkgSetting.sharedUser) {
11929 res.setError(INSTALL_FAILED_SHARED_USER_INCOMPATIBLE,
11930 "Forbidding shared user change from " + oldPkgSetting.sharedUser
11931 + " to " + newPkgSetting.sharedUser);
11932 updatedSettings = true;
11936 if (res.returnCode == PackageManager.INSTALL_SUCCEEDED) {
11937 updateSettingsLI(newPackage, installerPackageName, volumeUuid, allUsers,
11938 perUserInstalled, res, user);
11939 updatedSettings = true;
11942 } catch (PackageManagerException e) {
11943 res.setError("Package couldn't be installed in " + pkg.codePath, e);
11946 if (res.returnCode != PackageManager.INSTALL_SUCCEEDED) {
11947 // Re installation failed. Restore old information
11948 // Remove new pkg information
11949 if (newPackage != null) {
11950 removeInstalledPackageLI(newPackage, true);
11952 // Add back the old system package
11954 scanPackageLI(oldPkg, parseFlags, SCAN_UPDATE_SIGNATURE, 0, user);
11955 } catch (PackageManagerException e) {
11956 Slog.e(TAG, "Failed to restore original package: " + e.getMessage());
11958 // Restore the old system information in Settings
11959 synchronized (mPackages) {
11960 if (disabledSystem) {
11961 mSettings.enableSystemPackageLPw(packageName);
11963 if (updatedSettings) {
11964 mSettings.setInstallerPackageName(packageName,
11965 oldPkgSetting.installerPackageName);
11967 mSettings.writeLPr();
11972 private void updateSettingsLI(PackageParser.Package newPackage, String installerPackageName,
11973 String volumeUuid, int[] allUsers, boolean[] perUserInstalled, PackageInstalledInfo res,
11975 String pkgName = newPackage.packageName;
11976 synchronized (mPackages) {
11977 //write settings. the installStatus will be incomplete at this stage.
11978 //note that the new package setting would have already been
11979 //added to mPackages. It hasn't been persisted yet.
11980 mSettings.setInstallStatus(pkgName, PackageSettingBase.PKG_INSTALL_INCOMPLETE);
11981 mSettings.writeLPr();
11984 if (DEBUG_INSTALL) Slog.d(TAG, "New package installed in " + newPackage.codePath);
11986 synchronized (mPackages) {
11987 updatePermissionsLPw(newPackage.packageName, newPackage,
11988 UPDATE_PERMISSIONS_REPLACE_PKG | (newPackage.permissions.size() > 0
11989 ? UPDATE_PERMISSIONS_ALL : 0));
11990 // For system-bundled packages, we assume that installing an upgraded version
11991 // of the package implies that the user actually wants to run that new code,
11992 // so we enable the package.
11993 PackageSetting ps = mSettings.mPackages.get(pkgName);
11995 if (isSystemApp(newPackage)) {
11996 // NB: implicit assumption that system package upgrades apply to all users
11997 if (DEBUG_INSTALL) {
11998 Slog.d(TAG, "Implicitly enabling system package on upgrade: " + pkgName);
12000 if (res.origUsers != null) {
12001 for (int userHandle : res.origUsers) {
12002 ps.setEnabled(COMPONENT_ENABLED_STATE_DEFAULT,
12003 userHandle, installerPackageName);
12006 // Also convey the prior install/uninstall state
12007 if (allUsers != null && perUserInstalled != null) {
12008 for (int i = 0; i < allUsers.length; i++) {
12009 if (DEBUG_INSTALL) {
12010 Slog.d(TAG, " user " + allUsers[i]
12011 + " => " + perUserInstalled[i]);
12013 ps.setInstalled(perUserInstalled[i], allUsers[i]);
12015 // these install state changes will be persisted in the
12016 // upcoming call to mSettings.writeLPr().
12019 // It's implied that when a user requests installation, they want the app to be
12020 // installed and enabled.
12021 int userId = user.getIdentifier();
12022 if (userId != UserHandle.USER_ALL) {
12023 ps.setInstalled(true, userId);
12024 ps.setEnabled(COMPONENT_ENABLED_STATE_DEFAULT, userId, installerPackageName);
12027 res.name = pkgName;
12028 res.uid = newPackage.applicationInfo.uid;
12029 res.pkg = newPackage;
12030 mSettings.setInstallStatus(pkgName, PackageSettingBase.PKG_INSTALL_COMPLETE);
12031 mSettings.setInstallerPackageName(pkgName, installerPackageName);
12032 res.returnCode = PackageManager.INSTALL_SUCCEEDED;
12033 //to update install status
12034 mSettings.writeLPr();
12038 private void installPackageLI(InstallArgs args, PackageInstalledInfo res) {
12039 final int installFlags = args.installFlags;
12040 final String installerPackageName = args.installerPackageName;
12041 final String volumeUuid = args.volumeUuid;
12042 final File tmpPackageFile = new File(args.getCodePath());
12043 final boolean forwardLocked = ((installFlags & PackageManager.INSTALL_FORWARD_LOCK) != 0);
12044 final boolean onExternal = (((installFlags & PackageManager.INSTALL_EXTERNAL) != 0)
12045 || (args.volumeUuid != null));
12046 boolean replace = false;
12047 int scanFlags = SCAN_NEW_INSTALL | SCAN_UPDATE_SIGNATURE;
12048 if (args.move != null) {
12049 // moving a complete application; perfom an initial scan on the new install location
12050 scanFlags |= SCAN_INITIAL;
12052 // Result object to be returned
12053 res.returnCode = PackageManager.INSTALL_SUCCEEDED;
12055 if (DEBUG_INSTALL) Slog.d(TAG, "installPackageLI: path=" + tmpPackageFile);
12056 // Retrieve PackageSettings and parse package
12057 final int parseFlags = mDefParseFlags | PackageParser.PARSE_CHATTY
12058 | (forwardLocked ? PackageParser.PARSE_FORWARD_LOCK : 0)
12059 | (onExternal ? PackageParser.PARSE_EXTERNAL_STORAGE : 0);
12060 PackageParser pp = new PackageParser();
12061 pp.setSeparateProcesses(mSeparateProcesses);
12062 pp.setDisplayMetrics(mMetrics);
12064 final PackageParser.Package pkg;
12066 pkg = pp.parsePackage(tmpPackageFile, parseFlags);
12067 } catch (PackageParserException e) {
12068 res.setError("Failed parse during installPackageLI", e);
12072 // Mark that we have an install time CPU ABI override.
12073 pkg.cpuAbiOverride = args.abiOverride;
12075 String pkgName = res.name = pkg.packageName;
12076 if ((pkg.applicationInfo.flags&ApplicationInfo.FLAG_TEST_ONLY) != 0) {
12077 if ((installFlags & PackageManager.INSTALL_ALLOW_TEST) == 0) {
12078 res.setError(INSTALL_FAILED_TEST_ONLY, "installPackageLI");
12084 pp.collectCertificates(pkg, parseFlags);
12085 pp.collectManifestDigest(pkg);
12086 } catch (PackageParserException e) {
12087 res.setError("Failed collect during installPackageLI", e);
12091 /* If the installer passed in a manifest digest, compare it now. */
12092 if (args.manifestDigest != null) {
12093 if (DEBUG_INSTALL) {
12094 final String parsedManifest = pkg.manifestDigest == null ? "null"
12095 : pkg.manifestDigest.toString();
12096 Slog.d(TAG, "Comparing manifests: " + args.manifestDigest.toString() + " vs. "
12100 if (!args.manifestDigest.equals(pkg.manifestDigest)) {
12101 res.setError(INSTALL_FAILED_PACKAGE_CHANGED, "Manifest digest changed");
12104 } else if (DEBUG_INSTALL) {
12105 final String parsedManifest = pkg.manifestDigest == null
12106 ? "null" : pkg.manifestDigest.toString();
12107 Slog.d(TAG, "manifestDigest was not present, but parser got: " + parsedManifest);
12110 // Get rid of all references to package scan path via parser.
12112 String oldCodePath = null;
12113 boolean systemApp = false;
12114 synchronized (mPackages) {
12115 // Check if installing already existing package
12116 if ((installFlags & PackageManager.INSTALL_REPLACE_EXISTING) != 0) {
12117 String oldName = mSettings.mRenamedPackages.get(pkgName);
12118 if (pkg.mOriginalPackages != null
12119 && pkg.mOriginalPackages.contains(oldName)
12120 && mPackages.containsKey(oldName)) {
12121 // This package is derived from an original package,
12122 // and this device has been updating from that original
12123 // name. We must continue using the original name, so
12124 // rename the new package here.
12125 pkg.setPackageName(oldName);
12126 pkgName = pkg.packageName;
12128 if (DEBUG_INSTALL) Slog.d(TAG, "Replacing existing renamed package: oldName="
12129 + oldName + " pkgName=" + pkgName);
12130 } else if (mPackages.containsKey(pkgName)) {
12131 // This package, under its official name, already exists
12132 // on the device; we should replace it.
12134 if (DEBUG_INSTALL) Slog.d(TAG, "Replace existing pacakge: " + pkgName);
12137 // Prevent apps opting out from runtime permissions
12139 PackageParser.Package oldPackage = mPackages.get(pkgName);
12140 final int oldTargetSdk = oldPackage.applicationInfo.targetSdkVersion;
12141 final int newTargetSdk = pkg.applicationInfo.targetSdkVersion;
12142 if (oldTargetSdk > Build.VERSION_CODES.LOLLIPOP_MR1
12143 && newTargetSdk <= Build.VERSION_CODES.LOLLIPOP_MR1) {
12144 res.setError(PackageManager.INSTALL_FAILED_PERMISSION_MODEL_DOWNGRADE,
12145 "Package " + pkg.packageName + " new target SDK " + newTargetSdk
12146 + " doesn't support runtime permissions but the old"
12147 + " target SDK " + oldTargetSdk + " does.");
12153 PackageSetting ps = mSettings.mPackages.get(pkgName);
12155 if (DEBUG_INSTALL) Slog.d(TAG, "Existing package: " + ps);
12157 // Quick sanity check that we're signed correctly if updating;
12158 // we'll check this again later when scanning, but we want to
12159 // bail early here before tripping over redefined permissions.
12160 if (shouldCheckUpgradeKeySetLP(ps, scanFlags)) {
12161 if (!checkUpgradeKeySetLP(ps, pkg)) {
12162 res.setError(INSTALL_FAILED_UPDATE_INCOMPATIBLE, "Package "
12163 + pkg.packageName + " upgrade keys do not match the "
12164 + "previously installed version");
12169 verifySignaturesLP(ps, pkg);
12170 } catch (PackageManagerException e) {
12171 res.setError(e.error, e.getMessage());
12176 oldCodePath = mSettings.mPackages.get(pkgName).codePathString;
12177 if (ps.pkg != null && ps.pkg.applicationInfo != null) {
12178 systemApp = (ps.pkg.applicationInfo.flags &
12179 ApplicationInfo.FLAG_SYSTEM) != 0;
12181 res.origUsers = ps.queryInstalledUsers(sUserManager.getUserIds(), true);
12184 // Check whether the newly-scanned package wants to define an already-defined perm
12185 int N = pkg.permissions.size();
12186 for (int i = N-1; i >= 0; i--) {
12187 PackageParser.Permission perm = pkg.permissions.get(i);
12188 BasePermission bp = mSettings.mPermissions.get(perm.info.name);
12190 // If the defining package is signed with our cert, it's okay. This
12191 // also includes the "updating the same package" case, of course.
12192 // "updating same package" could also involve key-rotation.
12193 final boolean sigsOk;
12194 if (bp.sourcePackage.equals(pkg.packageName)
12195 && (bp.packageSetting instanceof PackageSetting)
12196 && (shouldCheckUpgradeKeySetLP((PackageSetting) bp.packageSetting,
12198 sigsOk = checkUpgradeKeySetLP((PackageSetting) bp.packageSetting, pkg);
12200 sigsOk = compareSignatures(bp.packageSetting.signatures.mSignatures,
12201 pkg.mSignatures) == PackageManager.SIGNATURE_MATCH;
12204 // If the owning package is the system itself, we log but allow
12205 // install to proceed; we fail the install on all other permission
12207 if (!bp.sourcePackage.equals("android")) {
12208 res.setError(INSTALL_FAILED_DUPLICATE_PERMISSION, "Package "
12209 + pkg.packageName + " attempting to redeclare permission "
12210 + perm.info.name + " already owned by " + bp.sourcePackage);
12211 res.origPermission = perm.info.name;
12212 res.origPackage = bp.sourcePackage;
12215 Slog.w(TAG, "Package " + pkg.packageName
12216 + " attempting to redeclare system permission "
12217 + perm.info.name + "; ignoring new declaration");
12218 pkg.permissions.remove(i);
12226 if (systemApp && onExternal) {
12227 // Disable updates to system apps on sdcard
12228 res.setError(INSTALL_FAILED_INVALID_INSTALL_LOCATION,
12229 "Cannot install updates to system apps on sdcard");
12233 if (args.move != null) {
12234 // We did an in-place move, so dex is ready to roll
12235 scanFlags |= SCAN_NO_DEX;
12236 scanFlags |= SCAN_MOVE;
12237 } else if (!forwardLocked && !pkg.applicationInfo.isExternalAsec()) {
12238 // Enable SCAN_NO_DEX flag to skip dexopt at a later stage
12239 scanFlags |= SCAN_NO_DEX;
12242 derivePackageAbi(pkg, new File(pkg.codePath), args.abiOverride,
12243 true /* extract libs */);
12244 } catch (PackageManagerException pme) {
12245 Slog.e(TAG, "Error deriving application ABI", pme);
12246 res.setError(INSTALL_FAILED_INTERNAL_ERROR, "Error deriving application ABI");
12250 // Run dexopt before old package gets removed, to minimize time when app is unavailable
12251 int result = mPackageDexOptimizer
12252 .performDexOpt(pkg, null /* instruction sets */, false /* forceDex */,
12253 false /* defer */, false /* inclDependencies */);
12254 if (result == PackageDexOptimizer.DEX_OPT_FAILED) {
12255 res.setError(INSTALL_FAILED_DEXOPT, "Dexopt failed for " + pkg.codePath);
12260 if (!args.doRename(res.returnCode, pkg, oldCodePath)) {
12261 res.setError(INSTALL_FAILED_INSUFFICIENT_STORAGE, "Failed rename");
12265 startIntentFilterVerifications(args.user.getIdentifier(), replace, pkg);
12268 replacePackageLI(pkg, parseFlags, scanFlags, args.user,
12269 installerPackageName, volumeUuid, res);
12271 installNewPackageLI(pkg, parseFlags, scanFlags | SCAN_DELETE_DATA_ON_FAILURES,
12272 args.user, installerPackageName, volumeUuid, res);
12274 synchronized (mPackages) {
12275 final PackageSetting ps = mSettings.mPackages.get(pkgName);
12277 res.newUsers = ps.queryInstalledUsers(sUserManager.getUserIds(), true);
12282 private void startIntentFilterVerifications(int userId, boolean replacing,
12283 PackageParser.Package pkg) {
12284 if (mIntentFilterVerifierComponent == null) {
12285 Slog.w(TAG, "No IntentFilter verification will not be done as "
12286 + "there is no IntentFilterVerifier available!");
12290 final int verifierUid = getPackageUid(
12291 mIntentFilterVerifierComponent.getPackageName(),
12292 (userId == UserHandle.USER_ALL) ? UserHandle.USER_OWNER : userId);
12294 mHandler.removeMessages(START_INTENT_FILTER_VERIFICATIONS);
12295 final Message msg = mHandler.obtainMessage(START_INTENT_FILTER_VERIFICATIONS);
12296 msg.obj = new IFVerificationParams(pkg, replacing, userId, verifierUid);
12297 mHandler.sendMessage(msg);
12300 private void verifyIntentFiltersIfNeeded(int userId, int verifierUid, boolean replacing,
12301 PackageParser.Package pkg) {
12302 int size = pkg.activities.size();
12304 if (DEBUG_DOMAIN_VERIFICATION) Slog.d(TAG,
12305 "No activity, so no need to verify any IntentFilter!");
12309 final boolean hasDomainURLs = hasDomainURLs(pkg);
12310 if (!hasDomainURLs) {
12311 if (DEBUG_DOMAIN_VERIFICATION) Slog.d(TAG,
12312 "No domain URLs, so no need to verify any IntentFilter!");
12316 if (DEBUG_DOMAIN_VERIFICATION) Slog.d(TAG, "Checking for userId:" + userId
12317 + " if any IntentFilter from the " + size
12318 + " Activities needs verification ...");
12321 final String packageName = pkg.packageName;
12323 synchronized (mPackages) {
12324 // If this is a new install and we see that we've already run verification for this
12325 // package, we have nothing to do: it means the state was restored from backup.
12327 IntentFilterVerificationInfo ivi =
12328 mSettings.getIntentFilterVerificationLPr(packageName);
12330 if (DEBUG_DOMAIN_VERIFICATION) {
12331 Slog.i(TAG, "Package " + packageName+ " already verified: status="
12332 + ivi.getStatusString());
12338 // If any filters need to be verified, then all need to be.
12339 boolean needToVerify = false;
12340 for (PackageParser.Activity a : pkg.activities) {
12341 for (ActivityIntentInfo filter : a.intents) {
12342 if (filter.needsVerification() && needsNetworkVerificationLPr(filter)) {
12343 if (DEBUG_DOMAIN_VERIFICATION) {
12344 Slog.d(TAG, "Intent filter needs verification, so processing all filters");
12346 needToVerify = true;
12352 if (needToVerify) {
12353 final int verificationId = mIntentFilterVerificationToken++;
12354 for (PackageParser.Activity a : pkg.activities) {
12355 for (ActivityIntentInfo filter : a.intents) {
12356 if (filter.handlesWebUris(true) && needsNetworkVerificationLPr(filter)) {
12357 if (DEBUG_DOMAIN_VERIFICATION) Slog.d(TAG,
12358 "Verification needed for IntentFilter:" + filter.toString());
12359 mIntentFilterVerifier.addOneIntentFilterVerification(
12360 verifierUid, userId, verificationId, filter, packageName);
12369 if (DEBUG_DOMAIN_VERIFICATION) Slog.d(TAG, "Starting " + count
12370 + " IntentFilter verification" + (count > 1 ? "s" : "")
12371 + " for userId:" + userId);
12372 mIntentFilterVerifier.startVerifications(userId);
12374 if (DEBUG_DOMAIN_VERIFICATION) {
12375 Slog.d(TAG, "No filters or not all autoVerify for " + packageName);
12380 private boolean needsNetworkVerificationLPr(ActivityIntentInfo filter) {
12381 final ComponentName cn = filter.activity.getComponentName();
12382 final String packageName = cn.getPackageName();
12384 IntentFilterVerificationInfo ivi = mSettings.getIntentFilterVerificationLPr(
12389 int status = ivi.getStatus();
12391 case INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_UNDEFINED:
12392 case INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_ASK:
12401 private static boolean isMultiArch(PackageSetting ps) {
12402 return (ps.pkgFlags & ApplicationInfo.FLAG_MULTIARCH) != 0;
12405 private static boolean isMultiArch(ApplicationInfo info) {
12406 return (info.flags & ApplicationInfo.FLAG_MULTIARCH) != 0;
12409 private static boolean isExternal(PackageParser.Package pkg) {
12410 return (pkg.applicationInfo.flags & ApplicationInfo.FLAG_EXTERNAL_STORAGE) != 0;
12413 private static boolean isExternal(PackageSetting ps) {
12414 return (ps.pkgFlags & ApplicationInfo.FLAG_EXTERNAL_STORAGE) != 0;
12417 private static boolean isExternal(ApplicationInfo info) {
12418 return (info.flags & ApplicationInfo.FLAG_EXTERNAL_STORAGE) != 0;
12421 private static boolean isSystemApp(PackageParser.Package pkg) {
12422 return (pkg.applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM) != 0;
12425 private static boolean isPrivilegedApp(PackageParser.Package pkg) {
12426 return (pkg.applicationInfo.privateFlags & ApplicationInfo.PRIVATE_FLAG_PRIVILEGED) != 0;
12429 private static boolean hasDomainURLs(PackageParser.Package pkg) {
12430 return (pkg.applicationInfo.privateFlags & ApplicationInfo.PRIVATE_FLAG_HAS_DOMAIN_URLS) != 0;
12433 private static boolean isSystemApp(PackageSetting ps) {
12434 return (ps.pkgFlags & ApplicationInfo.FLAG_SYSTEM) != 0;
12437 private static boolean isUpdatedSystemApp(PackageSetting ps) {
12438 return (ps.pkgFlags & ApplicationInfo.FLAG_UPDATED_SYSTEM_APP) != 0;
12441 private int packageFlagsToInstallFlags(PackageSetting ps) {
12442 int installFlags = 0;
12443 if (isExternal(ps) && TextUtils.isEmpty(ps.volumeUuid)) {
12444 // This existing package was an external ASEC install when we have
12445 // the external flag without a UUID
12446 installFlags |= PackageManager.INSTALL_EXTERNAL;
12448 if (ps.isForwardLocked()) {
12449 installFlags |= PackageManager.INSTALL_FORWARD_LOCK;
12451 return installFlags;
12454 private void deleteTempPackageFiles() {
12455 final FilenameFilter filter = new FilenameFilter() {
12456 public boolean accept(File dir, String name) {
12457 return name.startsWith("vmdl") && name.endsWith(".tmp");
12460 for (File file : mDrmAppPrivateInstallDir.listFiles(filter)) {
12466 public void deletePackageAsUser(String packageName, IPackageDeleteObserver observer, int userId,
12468 deletePackage(packageName, new LegacyPackageDeleteObserver(observer).getBinder(), userId,
12473 public void deletePackage(final String packageName,
12474 final IPackageDeleteObserver2 observer, final int userId, final int flags) {
12475 mContext.enforceCallingOrSelfPermission(
12476 android.Manifest.permission.DELETE_PACKAGES, null);
12477 Preconditions.checkNotNull(packageName);
12478 Preconditions.checkNotNull(observer);
12479 final int uid = Binder.getCallingUid();
12480 if (UserHandle.getUserId(uid) != userId) {
12481 mContext.enforceCallingPermission(
12482 android.Manifest.permission.INTERACT_ACROSS_USERS_FULL,
12483 "deletePackage for user " + userId);
12485 if (isUserRestricted(userId, UserManager.DISALLOW_UNINSTALL_APPS)) {
12487 observer.onPackageDeleted(packageName,
12488 PackageManager.DELETE_FAILED_USER_RESTRICTED, null);
12489 } catch (RemoteException re) {
12494 boolean uninstallBlocked = false;
12495 if ((flags & PackageManager.DELETE_ALL_USERS) != 0) {
12496 int[] users = sUserManager.getUserIds();
12497 for (int i = 0; i < users.length; ++i) {
12498 if (getBlockUninstallForUser(packageName, users[i])) {
12499 uninstallBlocked = true;
12504 uninstallBlocked = getBlockUninstallForUser(packageName, userId);
12506 if (uninstallBlocked) {
12508 observer.onPackageDeleted(packageName, PackageManager.DELETE_FAILED_OWNER_BLOCKED,
12510 } catch (RemoteException re) {
12515 if (DEBUG_REMOVE) {
12516 Slog.d(TAG, "deletePackageAsUser: pkg=" + packageName + " user=" + userId);
12518 // Queue up an async operation since the package deletion may take a little while.
12519 mHandler.post(new Runnable() {
12520 public void run() {
12521 mHandler.removeCallbacks(this);
12522 final int returnCode = deletePackageX(packageName, userId, flags);
12523 if (observer != null) {
12525 observer.onPackageDeleted(packageName, returnCode, null);
12526 } catch (RemoteException e) {
12527 Log.i(TAG, "Observer no longer exists.");
12534 private boolean isPackageDeviceAdmin(String packageName, int userId) {
12535 IDevicePolicyManager dpm = IDevicePolicyManager.Stub.asInterface(
12536 ServiceManager.getService(Context.DEVICE_POLICY_SERVICE));
12539 if (dpm.isDeviceOwner(packageName)) {
12543 if (userId == UserHandle.USER_ALL) {
12544 users = sUserManager.getUserIds();
12546 users = new int[]{userId};
12548 for (int i = 0; i < users.length; ++i) {
12549 if (dpm.packageHasActiveAdmins(packageName, users[i])) {
12554 } catch (RemoteException e) {
12560 * This method is an internal method that could be get invoked either
12561 * to delete an installed package or to clean up a failed installation.
12562 * After deleting an installed package, a broadcast is sent to notify any
12563 * listeners that the package has been installed. For cleaning up a failed
12564 * installation, the broadcast is not necessary since the package's
12565 * installation wouldn't have sent the initial broadcast either
12566 * The key steps in deleting a package are
12567 * deleting the package information in internal structures like mPackages,
12568 * deleting the packages base directories through installd
12569 * updating mSettings to reflect current status
12570 * persisting settings for later use
12571 * sending a broadcast if necessary
12573 private int deletePackageX(String packageName, int userId, int flags) {
12574 final PackageRemovedInfo info = new PackageRemovedInfo();
12577 final UserHandle removeForUser = (flags & PackageManager.DELETE_ALL_USERS) != 0
12578 ? UserHandle.ALL : new UserHandle(userId);
12580 if (isPackageDeviceAdmin(packageName, removeForUser.getIdentifier())) {
12581 Slog.w(TAG, "Not removing package " + packageName + ": has active device admin");
12582 return PackageManager.DELETE_FAILED_DEVICE_POLICY_MANAGER;
12585 boolean removedForAllUsers = false;
12586 boolean systemUpdate = false;
12588 // for the uninstall-updates case and restricted profiles, remember the per-
12589 // userhandle installed state
12591 boolean[] perUserInstalled;
12592 synchronized (mPackages) {
12593 PackageSetting ps = mSettings.mPackages.get(packageName);
12594 allUsers = sUserManager.getUserIds();
12595 perUserInstalled = new boolean[allUsers.length];
12596 for (int i = 0; i < allUsers.length; i++) {
12597 perUserInstalled[i] = ps != null ? ps.getInstalled(allUsers[i]) : false;
12601 synchronized (mInstallLock) {
12602 if (DEBUG_REMOVE) Slog.d(TAG, "deletePackageX: pkg=" + packageName + " user=" + userId);
12603 res = deletePackageLI(packageName, removeForUser,
12604 true, allUsers, perUserInstalled,
12605 flags | REMOVE_CHATTY, info, true);
12606 systemUpdate = info.isRemovedPackageSystemUpdate;
12607 if (res && !systemUpdate && mPackages.get(packageName) == null) {
12608 removedForAllUsers = true;
12610 if (DEBUG_REMOVE) Slog.d(TAG, "delete res: systemUpdate=" + systemUpdate
12611 + " removedForAllUsers=" + removedForAllUsers);
12615 info.sendBroadcast(true, systemUpdate, removedForAllUsers);
12617 // If the removed package was a system update, the old system package
12618 // was re-enabled; we need to broadcast this information
12619 if (systemUpdate) {
12620 Bundle extras = new Bundle(1);
12621 extras.putInt(Intent.EXTRA_UID, info.removedAppId >= 0
12622 ? info.removedAppId : info.uid);
12623 extras.putBoolean(Intent.EXTRA_REPLACING, true);
12625 sendPackageBroadcast(Intent.ACTION_PACKAGE_ADDED, packageName,
12626 extras, null, null, null);
12627 sendPackageBroadcast(Intent.ACTION_PACKAGE_REPLACED, packageName,
12628 extras, null, null, null);
12629 sendPackageBroadcast(Intent.ACTION_MY_PACKAGE_REPLACED, null,
12630 null, packageName, null, null);
12633 // Force a gc here.
12634 Runtime.getRuntime().gc();
12635 // Delete the resources here after sending the broadcast to let
12636 // other processes clean up before deleting resources.
12637 if (info.args != null) {
12638 synchronized (mInstallLock) {
12639 info.args.doPostDeleteLI(true);
12643 return res ? PackageManager.DELETE_SUCCEEDED : PackageManager.DELETE_FAILED_INTERNAL_ERROR;
12646 class PackageRemovedInfo {
12647 String removedPackage;
12649 int removedAppId = -1;
12650 int[] removedUsers = null;
12651 boolean isRemovedPackageSystemUpdate = false;
12652 // Clean up resources deleted packages.
12653 InstallArgs args = null;
12655 void sendBroadcast(boolean fullRemove, boolean replacing, boolean removedForAllUsers) {
12656 Bundle extras = new Bundle(1);
12657 extras.putInt(Intent.EXTRA_UID, removedAppId >= 0 ? removedAppId : uid);
12658 extras.putBoolean(Intent.EXTRA_DATA_REMOVED, fullRemove);
12660 extras.putBoolean(Intent.EXTRA_REPLACING, true);
12662 extras.putBoolean(Intent.EXTRA_REMOVED_FOR_ALL_USERS, removedForAllUsers);
12663 if (removedPackage != null) {
12664 sendPackageBroadcast(Intent.ACTION_PACKAGE_REMOVED, removedPackage,
12665 extras, null, null, removedUsers);
12666 if (fullRemove && !replacing) {
12667 sendPackageBroadcast(Intent.ACTION_PACKAGE_FULLY_REMOVED, removedPackage,
12668 extras, null, null, removedUsers);
12671 if (removedAppId >= 0) {
12672 sendPackageBroadcast(Intent.ACTION_UID_REMOVED, null, extras, null, null,
12679 * This method deletes the package from internal data structures. If the DONT_DELETE_DATA
12680 * flag is not set, the data directory is removed as well.
12681 * make sure this flag is set for partially installed apps. If not its meaningless to
12682 * delete a partially installed application.
12684 private void removePackageDataLI(PackageSetting ps,
12685 int[] allUserHandles, boolean[] perUserInstalled,
12686 PackageRemovedInfo outInfo, int flags, boolean writeSettings) {
12687 String packageName = ps.name;
12688 if (DEBUG_REMOVE) Slog.d(TAG, "removePackageDataLI: " + ps);
12689 removePackageLI(ps, (flags&REMOVE_CHATTY) != 0);
12690 // Retrieve object to delete permissions for shared user later on
12691 final PackageSetting deletedPs;
12693 synchronized (mPackages) {
12694 deletedPs = mSettings.mPackages.get(packageName);
12695 if (outInfo != null) {
12696 outInfo.removedPackage = packageName;
12697 outInfo.removedUsers = deletedPs != null
12698 ? deletedPs.queryInstalledUsers(sUserManager.getUserIds(), true)
12702 if ((flags&PackageManager.DELETE_KEEP_DATA) == 0) {
12703 removeDataDirsLI(ps.volumeUuid, packageName);
12704 schedulePackageCleaning(packageName, UserHandle.USER_ALL, true);
12707 synchronized (mPackages) {
12708 if (deletedPs != null) {
12709 if ((flags&PackageManager.DELETE_KEEP_DATA) == 0) {
12710 clearIntentFilterVerificationsLPw(deletedPs.name, UserHandle.USER_ALL);
12711 clearDefaultBrowserIfNeeded(packageName);
12712 if (outInfo != null) {
12713 mSettings.mKeySetManagerService.removeAppKeySetDataLPw(packageName);
12714 outInfo.removedAppId = mSettings.removePackageLPw(packageName);
12716 updatePermissionsLPw(deletedPs.name, null, 0);
12717 if (deletedPs.sharedUser != null) {
12718 // Remove permissions associated with package. Since runtime
12719 // permissions are per user we have to kill the removed package
12720 // or packages running under the shared user of the removed
12721 // package if revoking the permissions requested only by the removed
12722 // package is successful and this causes a change in gids.
12723 for (int userId : UserManagerService.getInstance().getUserIds()) {
12724 final int userIdToKill = mSettings.updateSharedUserPermsLPw(deletedPs,
12726 if (userIdToKill == UserHandle.USER_ALL
12727 || userIdToKill >= UserHandle.USER_OWNER) {
12728 // If gids changed for this user, kill all affected packages.
12729 mHandler.post(new Runnable() {
12731 public void run() {
12732 // This has to happen with no lock held.
12733 killSettingPackagesForUser(deletedPs, userIdToKill,
12734 KILL_APP_REASON_GIDS_CHANGED);
12741 clearPackagePreferredActivitiesLPw(deletedPs.name, UserHandle.USER_ALL);
12743 // make sure to preserve per-user disabled state if this removal was just
12744 // a downgrade of a system app to the factory package
12745 if (allUserHandles != null && perUserInstalled != null) {
12746 if (DEBUG_REMOVE) {
12747 Slog.d(TAG, "Propagating install state across downgrade");
12749 for (int i = 0; i < allUserHandles.length; i++) {
12750 if (DEBUG_REMOVE) {
12751 Slog.d(TAG, " user " + allUserHandles[i]
12752 + " => " + perUserInstalled[i]);
12754 ps.setInstalled(perUserInstalled[i], allUserHandles[i]);
12758 // can downgrade to reader
12759 if (writeSettings) {
12760 // Save settings now
12761 mSettings.writeLPr();
12764 if (outInfo != null) {
12765 // A user ID was deleted here. Go through all users and remove it
12767 removeKeystoreDataIfNeeded(UserHandle.USER_ALL, outInfo.removedAppId);
12771 static boolean locationIsPrivileged(File path) {
12773 final String privilegedAppDir = new File(Environment.getRootDirectory(), "priv-app")
12774 .getCanonicalPath();
12775 return path.getCanonicalPath().startsWith(privilegedAppDir);
12776 } catch (IOException e) {
12777 Slog.e(TAG, "Unable to access code path " + path);
12783 * Tries to delete system package.
12785 private boolean deleteSystemPackageLI(PackageSetting newPs,
12786 int[] allUserHandles, boolean[] perUserInstalled,
12787 int flags, PackageRemovedInfo outInfo, boolean writeSettings) {
12788 final boolean applyUserRestrictions
12789 = (allUserHandles != null) && (perUserInstalled != null);
12790 PackageSetting disabledPs = null;
12791 // Confirm if the system package has been updated
12792 // An updated system app can be deleted. This will also have to restore
12793 // the system pkg from system partition
12795 synchronized (mPackages) {
12796 disabledPs = mSettings.getDisabledSystemPkgLPr(newPs.name);
12798 if (DEBUG_REMOVE) Slog.d(TAG, "deleteSystemPackageLI: newPs=" + newPs
12799 + " disabledPs=" + disabledPs);
12800 if (disabledPs == null) {
12801 Slog.w(TAG, "Attempt to delete unknown system package "+ newPs.name);
12803 } else if (DEBUG_REMOVE) {
12804 Slog.d(TAG, "Deleting system pkg from data partition");
12806 if (DEBUG_REMOVE) {
12807 if (applyUserRestrictions) {
12808 Slog.d(TAG, "Remembering install states:");
12809 for (int i = 0; i < allUserHandles.length; i++) {
12810 Slog.d(TAG, " u=" + allUserHandles[i] + " inst=" + perUserInstalled[i]);
12814 // Delete the updated package
12815 outInfo.isRemovedPackageSystemUpdate = true;
12816 if (disabledPs.versionCode < newPs.versionCode) {
12817 // Delete data for downgrades
12818 flags &= ~PackageManager.DELETE_KEEP_DATA;
12820 // Preserve data by setting flag
12821 flags |= PackageManager.DELETE_KEEP_DATA;
12823 boolean ret = deleteInstalledPackageLI(newPs, true, flags,
12824 allUserHandles, perUserInstalled, outInfo, writeSettings);
12829 synchronized (mPackages) {
12830 // Reinstate the old system package
12831 mSettings.enableSystemPackageLPw(newPs.name);
12832 // Remove any native libraries from the upgraded package.
12833 NativeLibraryHelper.removeNativeBinariesLI(newPs.legacyNativeLibraryPathString);
12835 // Install the system package
12836 if (DEBUG_REMOVE) Slog.d(TAG, "Re-installing system package: " + disabledPs);
12837 int parseFlags = PackageParser.PARSE_MUST_BE_APK | PackageParser.PARSE_IS_SYSTEM;
12838 if (locationIsPrivileged(disabledPs.codePath)) {
12839 parseFlags |= PackageParser.PARSE_IS_PRIVILEGED;
12842 final PackageParser.Package newPkg;
12844 newPkg = scanPackageLI(disabledPs.codePath, parseFlags, SCAN_NO_PATHS, 0, null);
12845 } catch (PackageManagerException e) {
12846 Slog.w(TAG, "Failed to restore system package:" + newPs.name + ": " + e.getMessage());
12851 synchronized (mPackages) {
12852 PackageSetting ps = mSettings.mPackages.get(newPkg.packageName);
12854 // Propagate the permissions state as we do want to drop on the floor
12855 // runtime permissions. The update permissions method below will take
12856 // care of removing obsolete permissions and grant install permissions.
12857 ps.getPermissionsState().copyFrom(disabledPs.getPermissionsState());
12858 updatePermissionsLPw(newPkg.packageName, newPkg,
12859 UPDATE_PERMISSIONS_ALL | UPDATE_PERMISSIONS_REPLACE_PKG);
12861 if (applyUserRestrictions) {
12862 if (DEBUG_REMOVE) {
12863 Slog.d(TAG, "Propagating install state across reinstall");
12865 for (int i = 0; i < allUserHandles.length; i++) {
12866 if (DEBUG_REMOVE) {
12867 Slog.d(TAG, " user " + allUserHandles[i]
12868 + " => " + perUserInstalled[i]);
12870 ps.setInstalled(perUserInstalled[i], allUserHandles[i]);
12872 // Regardless of writeSettings we need to ensure that this restriction
12873 // state propagation is persisted
12874 mSettings.writeAllUsersPackageRestrictionsLPr();
12876 // can downgrade to reader here
12877 if (writeSettings) {
12878 mSettings.writeLPr();
12884 private boolean deleteInstalledPackageLI(PackageSetting ps,
12885 boolean deleteCodeAndResources, int flags,
12886 int[] allUserHandles, boolean[] perUserInstalled,
12887 PackageRemovedInfo outInfo, boolean writeSettings) {
12888 if (outInfo != null) {
12889 outInfo.uid = ps.appId;
12892 // Delete package data from internal structures and also remove data if flag is set
12893 removePackageDataLI(ps, allUserHandles, perUserInstalled, outInfo, flags, writeSettings);
12895 // Delete application code and resources
12896 if (deleteCodeAndResources && (outInfo != null)) {
12897 outInfo.args = createInstallArgsForExisting(packageFlagsToInstallFlags(ps),
12898 ps.codePathString, ps.resourcePathString, getAppDexInstructionSets(ps));
12899 if (DEBUG_SD_INSTALL) Slog.i(TAG, "args=" + outInfo.args);
12905 public boolean setBlockUninstallForUser(String packageName, boolean blockUninstall,
12907 mContext.enforceCallingOrSelfPermission(
12908 android.Manifest.permission.DELETE_PACKAGES, null);
12909 synchronized (mPackages) {
12910 PackageSetting ps = mSettings.mPackages.get(packageName);
12912 Log.i(TAG, "Package doesn't exist in set block uninstall " + packageName);
12915 if (!ps.getInstalled(userId)) {
12916 // Can't block uninstall for an app that is not installed or enabled.
12917 Log.i(TAG, "Package not installed in set block uninstall " + packageName);
12920 ps.setBlockUninstall(blockUninstall, userId);
12921 mSettings.writePackageRestrictionsLPr(userId);
12927 public boolean getBlockUninstallForUser(String packageName, int userId) {
12928 synchronized (mPackages) {
12929 PackageSetting ps = mSettings.mPackages.get(packageName);
12931 Log.i(TAG, "Package doesn't exist in get block uninstall " + packageName);
12934 return ps.getBlockUninstall(userId);
12939 * This method handles package deletion in general
12941 private boolean deletePackageLI(String packageName, UserHandle user,
12942 boolean deleteCodeAndResources, int[] allUserHandles, boolean[] perUserInstalled,
12943 int flags, PackageRemovedInfo outInfo,
12944 boolean writeSettings) {
12945 if (packageName == null) {
12946 Slog.w(TAG, "Attempt to delete null packageName.");
12949 if (DEBUG_REMOVE) Slog.d(TAG, "deletePackageLI: " + packageName + " user " + user);
12951 boolean dataOnly = false;
12952 int removeUser = -1;
12954 synchronized (mPackages) {
12955 ps = mSettings.mPackages.get(packageName);
12957 Slog.w(TAG, "Package named '" + packageName + "' doesn't exist.");
12960 if ((!isSystemApp(ps) || (flags&PackageManager.DELETE_SYSTEM_APP) != 0) && user != null
12961 && user.getIdentifier() != UserHandle.USER_ALL) {
12962 // The caller is asking that the package only be deleted for a single
12963 // user. To do this, we just mark its uninstalled state and delete
12964 // its data. If this is a system app, we only allow this to happen if
12965 // they have set the special DELETE_SYSTEM_APP which requests different
12966 // semantics than normal for uninstalling system apps.
12967 if (DEBUG_REMOVE) Slog.d(TAG, "Only deleting for single user");
12968 ps.setUserState(user.getIdentifier(),
12969 COMPONENT_ENABLED_STATE_DEFAULT,
12972 true, //notLaunched
12975 false, // blockUninstall
12976 INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_UNDEFINED, 0);
12977 if (!isSystemApp(ps)) {
12978 if (ps.isAnyInstalled(sUserManager.getUserIds())) {
12979 // Other user still have this package installed, so all
12980 // we need to do is clear this user's data and save that
12981 // it is uninstalled.
12982 if (DEBUG_REMOVE) Slog.d(TAG, "Still installed by other users");
12983 removeUser = user.getIdentifier();
12985 scheduleWritePackageRestrictionsLocked(removeUser);
12987 // We need to set it back to 'installed' so the uninstall
12988 // broadcasts will be sent correctly.
12989 if (DEBUG_REMOVE) Slog.d(TAG, "Not installed by other users, full delete");
12990 ps.setInstalled(true, user.getIdentifier());
12993 // This is a system app, so we assume that the
12994 // other users still have this package installed, so all
12995 // we need to do is clear this user's data and save that
12996 // it is uninstalled.
12997 if (DEBUG_REMOVE) Slog.d(TAG, "Deleting system app");
12998 removeUser = user.getIdentifier();
13000 scheduleWritePackageRestrictionsLocked(removeUser);
13005 if (removeUser >= 0) {
13006 // From above, we determined that we are deleting this only
13007 // for a single user. Continue the work here.
13008 if (DEBUG_REMOVE) Slog.d(TAG, "Updating install state for user: " + removeUser);
13009 if (outInfo != null) {
13010 outInfo.removedPackage = packageName;
13011 outInfo.removedAppId = appId;
13012 outInfo.removedUsers = new int[] {removeUser};
13014 mInstaller.clearUserData(ps.volumeUuid, packageName, removeUser);
13015 removeKeystoreDataIfNeeded(removeUser, appId);
13016 schedulePackageCleaning(packageName, removeUser, false);
13017 synchronized (mPackages) {
13018 if (clearPackagePreferredActivitiesLPw(packageName, removeUser)) {
13019 scheduleWritePackageRestrictionsLocked(removeUser);
13021 resetUserChangesToRuntimePermissionsAndFlagsLocked(ps, removeUser);
13027 // Delete application data first
13028 if (DEBUG_REMOVE) Slog.d(TAG, "Removing package data only");
13029 removePackageDataLI(ps, null, null, outInfo, flags, writeSettings);
13033 boolean ret = false;
13034 if (isSystemApp(ps)) {
13035 if (DEBUG_REMOVE) Slog.d(TAG, "Removing system package:" + ps.name);
13036 // When an updated system application is deleted we delete the existing resources as well and
13037 // fall back to existing code in system partition
13038 ret = deleteSystemPackageLI(ps, allUserHandles, perUserInstalled,
13039 flags, outInfo, writeSettings);
13041 if (DEBUG_REMOVE) Slog.d(TAG, "Removing non-system package:" + ps.name);
13042 // Kill application pre-emptively especially for apps on sd.
13043 killApplication(packageName, ps.appId, "uninstall pkg");
13044 ret = deleteInstalledPackageLI(ps, deleteCodeAndResources, flags,
13045 allUserHandles, perUserInstalled,
13046 outInfo, writeSettings);
13052 private final class ClearStorageConnection implements ServiceConnection {
13053 IMediaContainerService mContainerService;
13056 public void onServiceConnected(ComponentName name, IBinder service) {
13057 synchronized (this) {
13058 mContainerService = IMediaContainerService.Stub.asInterface(service);
13064 public void onServiceDisconnected(ComponentName name) {
13068 private void clearExternalStorageDataSync(String packageName, int userId, boolean allData) {
13069 final boolean mounted;
13070 if (Environment.isExternalStorageEmulated()) {
13073 final String status = Environment.getExternalStorageState();
13075 mounted = status.equals(Environment.MEDIA_MOUNTED)
13076 || status.equals(Environment.MEDIA_MOUNTED_READ_ONLY);
13083 final Intent containerIntent = new Intent().setComponent(DEFAULT_CONTAINER_COMPONENT);
13085 if (userId == UserHandle.USER_ALL) {
13086 users = sUserManager.getUserIds();
13088 users = new int[] { userId };
13090 final ClearStorageConnection conn = new ClearStorageConnection();
13091 if (mContext.bindServiceAsUser(
13092 containerIntent, conn, Context.BIND_AUTO_CREATE, UserHandle.OWNER)) {
13094 for (int curUser : users) {
13095 long timeout = SystemClock.uptimeMillis() + 5000;
13096 synchronized (conn) {
13097 long now = SystemClock.uptimeMillis();
13098 while (conn.mContainerService == null && now < timeout) {
13100 conn.wait(timeout - now);
13101 } catch (InterruptedException e) {
13105 if (conn.mContainerService == null) {
13109 final UserEnvironment userEnv = new UserEnvironment(curUser);
13110 clearDirectory(conn.mContainerService,
13111 userEnv.buildExternalStorageAppCacheDirs(packageName));
13113 clearDirectory(conn.mContainerService,
13114 userEnv.buildExternalStorageAppDataDirs(packageName));
13115 clearDirectory(conn.mContainerService,
13116 userEnv.buildExternalStorageAppMediaDirs(packageName));
13120 mContext.unbindService(conn);
13126 public void clearApplicationUserData(final String packageName,
13127 final IPackageDataObserver observer, final int userId) {
13128 mContext.enforceCallingOrSelfPermission(
13129 android.Manifest.permission.CLEAR_APP_USER_DATA, null);
13130 enforceCrossUserPermission(Binder.getCallingUid(), userId, true, false, "clear application data");
13131 // Queue up an async operation since the package deletion may take a little while.
13132 mHandler.post(new Runnable() {
13133 public void run() {
13134 mHandler.removeCallbacks(this);
13135 final boolean succeeded;
13136 synchronized (mInstallLock) {
13137 succeeded = clearApplicationUserDataLI(packageName, userId);
13139 clearExternalStorageDataSync(packageName, userId, true);
13141 // invoke DeviceStorageMonitor's update method to clear any notifications
13142 DeviceStorageMonitorInternal
13143 dsm = LocalServices.getService(DeviceStorageMonitorInternal.class);
13148 if(observer != null) {
13150 observer.onRemoveCompleted(packageName, succeeded);
13151 } catch (RemoteException e) {
13152 Log.i(TAG, "Observer no longer exists.");
13154 } //end if observer
13159 private boolean clearApplicationUserDataLI(String packageName, int userId) {
13160 if (packageName == null) {
13161 Slog.w(TAG, "Attempt to delete null packageName.");
13165 // Try finding details about the requested package
13166 PackageParser.Package pkg;
13167 synchronized (mPackages) {
13168 pkg = mPackages.get(packageName);
13170 final PackageSetting ps = mSettings.mPackages.get(packageName);
13177 Slog.w(TAG, "Package named '" + packageName + "' doesn't exist.");
13181 PackageSetting ps = (PackageSetting) pkg.mExtras;
13182 resetUserChangesToRuntimePermissionsAndFlagsLocked(ps, userId);
13185 // Always delete data directories for package, even if we found no other
13186 // record of app. This helps users recover from UID mismatches without
13187 // resorting to a full data wipe.
13188 int retCode = mInstaller.clearUserData(pkg.volumeUuid, packageName, userId);
13190 Slog.w(TAG, "Couldn't remove cache files for package: " + packageName);
13194 final int appId = pkg.applicationInfo.uid;
13195 removeKeystoreDataIfNeeded(userId, appId);
13197 // Create a native library symlink only if we have native libraries
13198 // and if the native libraries are 32 bit libraries. We do not provide
13199 // this symlink for 64 bit libraries.
13200 if (pkg.applicationInfo.primaryCpuAbi != null &&
13201 !VMRuntime.is64BitAbi(pkg.applicationInfo.primaryCpuAbi)) {
13202 final String nativeLibPath = pkg.applicationInfo.nativeLibraryDir;
13203 if (mInstaller.linkNativeLibraryDirectory(pkg.volumeUuid, pkg.packageName,
13204 nativeLibPath, userId) < 0) {
13205 Slog.w(TAG, "Failed linking native library dir");
13214 * Reverts user permission state changes (permissions and flags).
13216 * @param ps The package for which to reset.
13217 * @param userId The device user for which to do a reset.
13219 private void resetUserChangesToRuntimePermissionsAndFlagsLocked(
13220 final PackageSetting ps, final int userId) {
13221 if (ps.pkg == null) {
13225 final int userSettableFlags = FLAG_PERMISSION_USER_SET
13226 | FLAG_PERMISSION_USER_FIXED
13227 | FLAG_PERMISSION_REVOKE_ON_UPGRADE;
13229 final int policyOrSystemFlags = FLAG_PERMISSION_SYSTEM_FIXED
13230 | FLAG_PERMISSION_POLICY_FIXED;
13232 boolean writeInstallPermissions = false;
13233 boolean writeRuntimePermissions = false;
13235 final int permissionCount = ps.pkg.requestedPermissions.size();
13236 for (int i = 0; i < permissionCount; i++) {
13237 String permission = ps.pkg.requestedPermissions.get(i);
13239 BasePermission bp = mSettings.mPermissions.get(permission);
13244 // If shared user we just reset the state to which only this app contributed.
13245 if (ps.sharedUser != null) {
13246 boolean used = false;
13247 final int packageCount = ps.sharedUser.packages.size();
13248 for (int j = 0; j < packageCount; j++) {
13249 PackageSetting pkg = ps.sharedUser.packages.valueAt(j);
13250 if (pkg.pkg != null && !pkg.pkg.packageName.equals(ps.pkg.packageName)
13251 && pkg.pkg.requestedPermissions.contains(permission)) {
13261 PermissionsState permissionsState = ps.getPermissionsState();
13263 final int oldFlags = permissionsState.getPermissionFlags(bp.name, userId);
13265 // Always clear the user settable flags.
13266 final boolean hasInstallState = permissionsState.getInstallPermissionState(
13268 if (permissionsState.updatePermissionFlags(bp, userId, userSettableFlags, 0)) {
13269 if (hasInstallState) {
13270 writeInstallPermissions = true;
13272 writeRuntimePermissions = true;
13276 // Below is only runtime permission handling.
13277 if (!bp.isRuntime()) {
13281 // Never clobber system or policy.
13282 if ((oldFlags & policyOrSystemFlags) != 0) {
13286 // If this permission was granted by default, make sure it is.
13287 if ((oldFlags & FLAG_PERMISSION_GRANTED_BY_DEFAULT) != 0) {
13288 if (permissionsState.grantRuntimePermission(bp, userId)
13289 != PERMISSION_OPERATION_FAILURE) {
13290 writeRuntimePermissions = true;
13293 // Otherwise, reset the permission.
13294 final int revokeResult = permissionsState.revokeRuntimePermission(bp, userId);
13295 switch (revokeResult) {
13296 case PERMISSION_OPERATION_SUCCESS: {
13297 writeRuntimePermissions = true;
13300 case PERMISSION_OPERATION_SUCCESS_GIDS_CHANGED: {
13301 writeRuntimePermissions = true;
13302 // If gids changed for this user, kill all affected packages.
13303 mHandler.post(new Runnable() {
13305 public void run() {
13306 // This has to happen with no lock held.
13307 killSettingPackagesForUser(ps, userId,
13308 KILL_APP_REASON_GIDS_CHANGED);
13316 // Synchronously write as we are taking permissions away.
13317 if (writeRuntimePermissions) {
13318 mSettings.writeRuntimePermissionsForUserLPr(userId, true);
13321 // Synchronously write as we are taking permissions away.
13322 if (writeInstallPermissions) {
13323 mSettings.writeLPr();
13328 * Remove entries from the keystore daemon. Will only remove it if the
13329 * {@code appId} is valid.
13331 private static void removeKeystoreDataIfNeeded(int userId, int appId) {
13336 final KeyStore keyStore = KeyStore.getInstance();
13337 if (keyStore != null) {
13338 if (userId == UserHandle.USER_ALL) {
13339 for (final int individual : sUserManager.getUserIds()) {
13340 keyStore.clearUid(UserHandle.getUid(individual, appId));
13343 keyStore.clearUid(UserHandle.getUid(userId, appId));
13346 Slog.w(TAG, "Could not contact keystore to clear entries for app id " + appId);
13351 public void deleteApplicationCacheFiles(final String packageName,
13352 final IPackageDataObserver observer) {
13353 mContext.enforceCallingOrSelfPermission(
13354 android.Manifest.permission.DELETE_CACHE_FILES, null);
13355 // Queue up an async operation since the package deletion may take a little while.
13356 final int userId = UserHandle.getCallingUserId();
13357 mHandler.post(new Runnable() {
13358 public void run() {
13359 mHandler.removeCallbacks(this);
13360 final boolean succeded;
13361 synchronized (mInstallLock) {
13362 succeded = deleteApplicationCacheFilesLI(packageName, userId);
13364 clearExternalStorageDataSync(packageName, userId, false);
13365 if (observer != null) {
13367 observer.onRemoveCompleted(packageName, succeded);
13368 } catch (RemoteException e) {
13369 Log.i(TAG, "Observer no longer exists.");
13371 } //end if observer
13376 private boolean deleteApplicationCacheFilesLI(String packageName, int userId) {
13377 if (packageName == null) {
13378 Slog.w(TAG, "Attempt to delete null packageName.");
13381 PackageParser.Package p;
13382 synchronized (mPackages) {
13383 p = mPackages.get(packageName);
13386 Slog.w(TAG, "Package named '" + packageName +"' doesn't exist.");
13389 final ApplicationInfo applicationInfo = p.applicationInfo;
13390 if (applicationInfo == null) {
13391 Slog.w(TAG, "Package " + packageName + " has no applicationInfo.");
13394 int retCode = mInstaller.deleteCacheFiles(p.volumeUuid, packageName, userId);
13396 Slog.w(TAG, "Couldn't remove cache files for package: "
13397 + packageName + " u" + userId);
13404 public void getPackageSizeInfo(final String packageName, int userHandle,
13405 final IPackageStatsObserver observer) {
13406 mContext.enforceCallingOrSelfPermission(
13407 android.Manifest.permission.GET_PACKAGE_SIZE, null);
13408 if (packageName == null) {
13409 throw new IllegalArgumentException("Attempt to get size of null packageName");
13412 PackageStats stats = new PackageStats(packageName, userHandle);
13415 * Queue up an async operation since the package measurement may take a
13418 Message msg = mHandler.obtainMessage(INIT_COPY);
13419 msg.obj = new MeasureParams(stats, observer);
13420 mHandler.sendMessage(msg);
13423 private boolean getPackageSizeInfoLI(String packageName, int userHandle,
13424 PackageStats pStats) {
13425 if (packageName == null) {
13426 Slog.w(TAG, "Attempt to get size of null packageName.");
13429 PackageParser.Package p;
13430 boolean dataOnly = false;
13431 String libDirRoot = null;
13432 String asecPath = null;
13433 PackageSetting ps = null;
13434 synchronized (mPackages) {
13435 p = mPackages.get(packageName);
13436 ps = mSettings.mPackages.get(packageName);
13439 if((ps == null) || (ps.pkg == null)) {
13440 Slog.w(TAG, "Package named '" + packageName +"' doesn't exist.");
13446 libDirRoot = ps.legacyNativeLibraryPathString;
13448 if (p != null && (isExternal(p) || p.isForwardLocked())) {
13449 String secureContainerId = cidFromCodePath(p.applicationInfo.getBaseCodePath());
13450 if (secureContainerId != null) {
13451 asecPath = PackageHelper.getSdFilesystem(secureContainerId);
13455 String publicSrcDir = null;
13457 final ApplicationInfo applicationInfo = p.applicationInfo;
13458 if (applicationInfo == null) {
13459 Slog.w(TAG, "Package " + packageName + " has no applicationInfo.");
13462 if (p.isForwardLocked()) {
13463 publicSrcDir = applicationInfo.getBaseResourcePath();
13466 // TODO: extend to measure size of split APKs
13467 // TODO(multiArch): Extend getSizeInfo to look at the full subdirectory tree,
13468 // not just the first level.
13469 // TODO(multiArch): Extend getSizeInfo to look at *all* instruction sets, not
13470 // just the primary.
13471 String[] dexCodeInstructionSets = getDexCodeInstructionSets(getAppDexInstructionSets(ps));
13472 int res = mInstaller.getSizeInfo(p.volumeUuid, packageName, userHandle, p.baseCodePath,
13473 libDirRoot, publicSrcDir, asecPath, dexCodeInstructionSets, pStats);
13478 // Fix-up for forward-locked applications in ASEC containers.
13479 if (!isExternal(p)) {
13480 pStats.codeSize += pStats.externalCodeSize;
13481 pStats.externalCodeSize = 0L;
13489 public void addPackageToPreferred(String packageName) {
13490 Slog.w(TAG, "addPackageToPreferred: this is now a no-op");
13494 public void removePackageFromPreferred(String packageName) {
13495 Slog.w(TAG, "removePackageFromPreferred: this is now a no-op");
13499 public List<PackageInfo> getPreferredPackages(int flags) {
13500 return new ArrayList<PackageInfo>();
13503 private int getUidTargetSdkVersionLockedLPr(int uid) {
13504 Object obj = mSettings.getUserIdLPr(uid);
13505 if (obj instanceof SharedUserSetting) {
13506 final SharedUserSetting sus = (SharedUserSetting) obj;
13507 int vers = Build.VERSION_CODES.CUR_DEVELOPMENT;
13508 final Iterator<PackageSetting> it = sus.packages.iterator();
13509 while (it.hasNext()) {
13510 final PackageSetting ps = it.next();
13511 if (ps.pkg != null) {
13512 int v = ps.pkg.applicationInfo.targetSdkVersion;
13513 if (v < vers) vers = v;
13517 } else if (obj instanceof PackageSetting) {
13518 final PackageSetting ps = (PackageSetting) obj;
13519 if (ps.pkg != null) {
13520 return ps.pkg.applicationInfo.targetSdkVersion;
13523 return Build.VERSION_CODES.CUR_DEVELOPMENT;
13527 public void addPreferredActivity(IntentFilter filter, int match,
13528 ComponentName[] set, ComponentName activity, int userId) {
13529 addPreferredActivityInternal(filter, match, set, activity, true, userId,
13530 "Adding preferred");
13533 private void addPreferredActivityInternal(IntentFilter filter, int match,
13534 ComponentName[] set, ComponentName activity, boolean always, int userId,
13537 int callingUid = Binder.getCallingUid();
13538 enforceCrossUserPermission(callingUid, userId, true, false, "add preferred activity");
13539 if (filter.countActions() == 0) {
13540 Slog.w(TAG, "Cannot set a preferred activity with no filter actions");
13543 synchronized (mPackages) {
13544 if (mContext.checkCallingOrSelfPermission(
13545 android.Manifest.permission.SET_PREFERRED_APPLICATIONS)
13546 != PackageManager.PERMISSION_GRANTED) {
13547 if (getUidTargetSdkVersionLockedLPr(callingUid)
13548 < Build.VERSION_CODES.FROYO) {
13549 Slog.w(TAG, "Ignoring addPreferredActivity() from uid "
13553 mContext.enforceCallingOrSelfPermission(
13554 android.Manifest.permission.SET_PREFERRED_APPLICATIONS, null);
13557 PreferredIntentResolver pir = mSettings.editPreferredActivitiesLPw(userId);
13558 Slog.i(TAG, opname + " activity " + activity.flattenToShortString() + " for user "
13560 filter.dump(new LogPrinter(Log.INFO, TAG), " ");
13561 pir.addFilter(new PreferredActivity(filter, match, set, activity, always));
13562 scheduleWritePackageRestrictionsLocked(userId);
13567 public void replacePreferredActivity(IntentFilter filter, int match,
13568 ComponentName[] set, ComponentName activity, int userId) {
13569 if (filter.countActions() != 1) {
13570 throw new IllegalArgumentException(
13571 "replacePreferredActivity expects filter to have only 1 action.");
13573 if (filter.countDataAuthorities() != 0
13574 || filter.countDataPaths() != 0
13575 || filter.countDataSchemes() > 1
13576 || filter.countDataTypes() != 0) {
13577 throw new IllegalArgumentException(
13578 "replacePreferredActivity expects filter to have no data authorities, " +
13579 "paths, or types; and at most one scheme.");
13582 final int callingUid = Binder.getCallingUid();
13583 enforceCrossUserPermission(callingUid, userId, true, false, "replace preferred activity");
13584 synchronized (mPackages) {
13585 if (mContext.checkCallingOrSelfPermission(
13586 android.Manifest.permission.SET_PREFERRED_APPLICATIONS)
13587 != PackageManager.PERMISSION_GRANTED) {
13588 if (getUidTargetSdkVersionLockedLPr(callingUid)
13589 < Build.VERSION_CODES.FROYO) {
13590 Slog.w(TAG, "Ignoring replacePreferredActivity() from uid "
13591 + Binder.getCallingUid());
13594 mContext.enforceCallingOrSelfPermission(
13595 android.Manifest.permission.SET_PREFERRED_APPLICATIONS, null);
13598 PreferredIntentResolver pir = mSettings.mPreferredActivities.get(userId);
13600 // Get all of the existing entries that exactly match this filter.
13601 ArrayList<PreferredActivity> existing = pir.findFilters(filter);
13602 if (existing != null && existing.size() == 1) {
13603 PreferredActivity cur = existing.get(0);
13604 if (DEBUG_PREFERRED) {
13605 Slog.i(TAG, "Checking replace of preferred:");
13606 filter.dump(new LogPrinter(Log.INFO, TAG), " ");
13607 if (!cur.mPref.mAlways) {
13608 Slog.i(TAG, " -- CUR; not mAlways!");
13610 Slog.i(TAG, " -- CUR: mMatch=" + cur.mPref.mMatch);
13611 Slog.i(TAG, " -- CUR: mSet="
13612 + Arrays.toString(cur.mPref.mSetComponents));
13613 Slog.i(TAG, " -- CUR: mComponent=" + cur.mPref.mShortComponent);
13614 Slog.i(TAG, " -- NEW: mMatch="
13615 + (match&IntentFilter.MATCH_CATEGORY_MASK));
13616 Slog.i(TAG, " -- CUR: mSet=" + Arrays.toString(set));
13617 Slog.i(TAG, " -- CUR: mComponent=" + activity.flattenToShortString());
13620 if (cur.mPref.mAlways && cur.mPref.mComponent.equals(activity)
13621 && cur.mPref.mMatch == (match&IntentFilter.MATCH_CATEGORY_MASK)
13622 && cur.mPref.sameSet(set)) {
13623 // Setting the preferred activity to what it happens to be already
13624 if (DEBUG_PREFERRED) {
13625 Slog.i(TAG, "Replacing with same preferred activity "
13626 + cur.mPref.mShortComponent + " for user "
13628 filter.dump(new LogPrinter(Log.INFO, TAG), " ");
13634 if (existing != null) {
13635 if (DEBUG_PREFERRED) {
13636 Slog.i(TAG, existing.size() + " existing preferred matches for:");
13637 filter.dump(new LogPrinter(Log.INFO, TAG), " ");
13639 for (int i = 0; i < existing.size(); i++) {
13640 PreferredActivity pa = existing.get(i);
13641 if (DEBUG_PREFERRED) {
13642 Slog.i(TAG, "Removing existing preferred activity "
13643 + pa.mPref.mComponent + ":");
13644 pa.dump(new LogPrinter(Log.INFO, TAG), " ");
13646 pir.removeFilter(pa);
13650 addPreferredActivityInternal(filter, match, set, activity, true, userId,
13651 "Replacing preferred");
13656 public void clearPackagePreferredActivities(String packageName) {
13657 final int uid = Binder.getCallingUid();
13659 synchronized (mPackages) {
13660 PackageParser.Package pkg = mPackages.get(packageName);
13661 if (pkg == null || pkg.applicationInfo.uid != uid) {
13662 if (mContext.checkCallingOrSelfPermission(
13663 android.Manifest.permission.SET_PREFERRED_APPLICATIONS)
13664 != PackageManager.PERMISSION_GRANTED) {
13665 if (getUidTargetSdkVersionLockedLPr(Binder.getCallingUid())
13666 < Build.VERSION_CODES.FROYO) {
13667 Slog.w(TAG, "Ignoring clearPackagePreferredActivities() from uid "
13668 + Binder.getCallingUid());
13671 mContext.enforceCallingOrSelfPermission(
13672 android.Manifest.permission.SET_PREFERRED_APPLICATIONS, null);
13676 int user = UserHandle.getCallingUserId();
13677 if (clearPackagePreferredActivitiesLPw(packageName, user)) {
13678 scheduleWritePackageRestrictionsLocked(user);
13683 /** This method takes a specific user id as well as UserHandle.USER_ALL. */
13684 boolean clearPackagePreferredActivitiesLPw(String packageName, int userId) {
13685 ArrayList<PreferredActivity> removed = null;
13686 boolean changed = false;
13687 for (int i=0; i<mSettings.mPreferredActivities.size(); i++) {
13688 final int thisUserId = mSettings.mPreferredActivities.keyAt(i);
13689 PreferredIntentResolver pir = mSettings.mPreferredActivities.valueAt(i);
13690 if (userId != UserHandle.USER_ALL && userId != thisUserId) {
13693 Iterator<PreferredActivity> it = pir.filterIterator();
13694 while (it.hasNext()) {
13695 PreferredActivity pa = it.next();
13696 // Mark entry for removal only if it matches the package name
13697 // and the entry is of type "always".
13698 if (packageName == null ||
13699 (pa.mPref.mComponent.getPackageName().equals(packageName)
13700 && pa.mPref.mAlways)) {
13701 if (removed == null) {
13702 removed = new ArrayList<PreferredActivity>();
13707 if (removed != null) {
13708 for (int j=0; j<removed.size(); j++) {
13709 PreferredActivity pa = removed.get(j);
13710 pir.removeFilter(pa);
13718 /** This method takes a specific user id as well as UserHandle.USER_ALL. */
13719 void clearIntentFilterVerificationsLPw(String packageName, int userId) {
13720 if (userId == UserHandle.USER_ALL) {
13721 if (mSettings.removeIntentFilterVerificationLPw(packageName,
13722 sUserManager.getUserIds())) {
13723 for (int oneUserId : sUserManager.getUserIds()) {
13724 scheduleWritePackageRestrictionsLocked(oneUserId);
13728 if (mSettings.removeIntentFilterVerificationLPw(packageName, userId)) {
13729 scheduleWritePackageRestrictionsLocked(userId);
13735 void clearDefaultBrowserIfNeeded(String packageName) {
13736 for (int oneUserId : sUserManager.getUserIds()) {
13737 String defaultBrowserPackageName = getDefaultBrowserPackageName(oneUserId);
13738 if (TextUtils.isEmpty(defaultBrowserPackageName)) continue;
13739 if (packageName.equals(defaultBrowserPackageName)) {
13740 setDefaultBrowserPackageName(null, oneUserId);
13746 public void resetPreferredActivities(int userId) {
13747 mContext.enforceCallingOrSelfPermission(
13748 android.Manifest.permission.SET_PREFERRED_APPLICATIONS, null);
13750 synchronized (mPackages) {
13751 clearPackagePreferredActivitiesLPw(null, userId);
13752 mSettings.applyDefaultPreferredAppsLPw(this, userId);
13753 applyFactoryDefaultBrowserLPw(userId);
13754 primeDomainVerificationsLPw(userId);
13756 scheduleWritePackageRestrictionsLocked(userId);
13761 public int getPreferredActivities(List<IntentFilter> outFilters,
13762 List<ComponentName> outActivities, String packageName) {
13765 final int userId = UserHandle.getCallingUserId();
13767 synchronized (mPackages) {
13768 PreferredIntentResolver pir = mSettings.mPreferredActivities.get(userId);
13770 final Iterator<PreferredActivity> it = pir.filterIterator();
13771 while (it.hasNext()) {
13772 final PreferredActivity pa = it.next();
13773 if (packageName == null
13774 || (pa.mPref.mComponent.getPackageName().equals(packageName)
13775 && pa.mPref.mAlways)) {
13776 if (outFilters != null) {
13777 outFilters.add(new IntentFilter(pa));
13779 if (outActivities != null) {
13780 outActivities.add(pa.mPref.mComponent);
13791 public void addPersistentPreferredActivity(IntentFilter filter, ComponentName activity,
13793 int callingUid = Binder.getCallingUid();
13794 if (callingUid != Process.SYSTEM_UID) {
13795 throw new SecurityException(
13796 "addPersistentPreferredActivity can only be run by the system");
13798 if (filter.countActions() == 0) {
13799 Slog.w(TAG, "Cannot set a preferred activity with no filter actions");
13802 synchronized (mPackages) {
13803 Slog.i(TAG, "Adding persistent preferred activity " + activity + " for user " + userId +
13805 filter.dump(new LogPrinter(Log.INFO, TAG), " ");
13806 mSettings.editPersistentPreferredActivitiesLPw(userId).addFilter(
13807 new PersistentPreferredActivity(filter, activity));
13808 scheduleWritePackageRestrictionsLocked(userId);
13813 public void clearPackagePersistentPreferredActivities(String packageName, int userId) {
13814 int callingUid = Binder.getCallingUid();
13815 if (callingUid != Process.SYSTEM_UID) {
13816 throw new SecurityException(
13817 "clearPackagePersistentPreferredActivities can only be run by the system");
13819 ArrayList<PersistentPreferredActivity> removed = null;
13820 boolean changed = false;
13821 synchronized (mPackages) {
13822 for (int i=0; i<mSettings.mPersistentPreferredActivities.size(); i++) {
13823 final int thisUserId = mSettings.mPersistentPreferredActivities.keyAt(i);
13824 PersistentPreferredIntentResolver ppir = mSettings.mPersistentPreferredActivities
13826 if (userId != thisUserId) {
13829 Iterator<PersistentPreferredActivity> it = ppir.filterIterator();
13830 while (it.hasNext()) {
13831 PersistentPreferredActivity ppa = it.next();
13832 // Mark entry for removal only if it matches the package name.
13833 if (ppa.mComponent.getPackageName().equals(packageName)) {
13834 if (removed == null) {
13835 removed = new ArrayList<PersistentPreferredActivity>();
13840 if (removed != null) {
13841 for (int j=0; j<removed.size(); j++) {
13842 PersistentPreferredActivity ppa = removed.get(j);
13843 ppir.removeFilter(ppa);
13850 scheduleWritePackageRestrictionsLocked(userId);
13856 * Common machinery for picking apart a restored XML blob and passing
13857 * it to a caller-supplied functor to be applied to the running system.
13859 private void restoreFromXml(XmlPullParser parser, int userId,
13860 String expectedStartTag, BlobXmlRestorer functor)
13861 throws IOException, XmlPullParserException {
13863 while ((type = parser.next()) != XmlPullParser.START_TAG
13864 && type != XmlPullParser.END_DOCUMENT) {
13866 if (type != XmlPullParser.START_TAG) {
13867 // oops didn't find a start tag?!
13868 if (DEBUG_BACKUP) {
13869 Slog.e(TAG, "Didn't find start tag during restore");
13874 // this is supposed to be TAG_PREFERRED_BACKUP
13875 if (!expectedStartTag.equals(parser.getName())) {
13876 if (DEBUG_BACKUP) {
13877 Slog.e(TAG, "Found unexpected tag " + parser.getName());
13882 // skip interfering stuff, then we're aligned with the backing implementation
13883 while ((type = parser.next()) == XmlPullParser.TEXT) { }
13884 functor.apply(parser, userId);
13887 private interface BlobXmlRestorer {
13888 public void apply(XmlPullParser parser, int userId) throws IOException, XmlPullParserException;
13892 * Non-Binder method, support for the backup/restore mechanism: write the
13893 * full set of preferred activities in its canonical XML format. Returns the
13894 * XML output as a byte array, or null if there is none.
13897 public byte[] getPreferredActivityBackup(int userId) {
13898 if (Binder.getCallingUid() != Process.SYSTEM_UID) {
13899 throw new SecurityException("Only the system may call getPreferredActivityBackup()");
13902 ByteArrayOutputStream dataStream = new ByteArrayOutputStream();
13904 final XmlSerializer serializer = new FastXmlSerializer();
13905 serializer.setOutput(dataStream, StandardCharsets.UTF_8.name());
13906 serializer.startDocument(null, true);
13907 serializer.startTag(null, TAG_PREFERRED_BACKUP);
13909 synchronized (mPackages) {
13910 mSettings.writePreferredActivitiesLPr(serializer, userId, true);
13913 serializer.endTag(null, TAG_PREFERRED_BACKUP);
13914 serializer.endDocument();
13915 serializer.flush();
13916 } catch (Exception e) {
13917 if (DEBUG_BACKUP) {
13918 Slog.e(TAG, "Unable to write preferred activities for backup", e);
13923 return dataStream.toByteArray();
13927 public void restorePreferredActivities(byte[] backup, int userId) {
13928 if (Binder.getCallingUid() != Process.SYSTEM_UID) {
13929 throw new SecurityException("Only the system may call restorePreferredActivities()");
13933 final XmlPullParser parser = Xml.newPullParser();
13934 parser.setInput(new ByteArrayInputStream(backup), StandardCharsets.UTF_8.name());
13935 restoreFromXml(parser, userId, TAG_PREFERRED_BACKUP,
13936 new BlobXmlRestorer() {
13938 public void apply(XmlPullParser parser, int userId)
13939 throws XmlPullParserException, IOException {
13940 synchronized (mPackages) {
13941 mSettings.readPreferredActivitiesLPw(parser, userId);
13945 } catch (Exception e) {
13946 if (DEBUG_BACKUP) {
13947 Slog.e(TAG, "Exception restoring preferred activities: " + e.getMessage());
13953 * Non-Binder method, support for the backup/restore mechanism: write the
13954 * default browser (etc) settings in its canonical XML format. Returns the default
13955 * browser XML representation as a byte array, or null if there is none.
13958 public byte[] getDefaultAppsBackup(int userId) {
13959 if (Binder.getCallingUid() != Process.SYSTEM_UID) {
13960 throw new SecurityException("Only the system may call getDefaultAppsBackup()");
13963 ByteArrayOutputStream dataStream = new ByteArrayOutputStream();
13965 final XmlSerializer serializer = new FastXmlSerializer();
13966 serializer.setOutput(dataStream, StandardCharsets.UTF_8.name());
13967 serializer.startDocument(null, true);
13968 serializer.startTag(null, TAG_DEFAULT_APPS);
13970 synchronized (mPackages) {
13971 mSettings.writeDefaultAppsLPr(serializer, userId);
13974 serializer.endTag(null, TAG_DEFAULT_APPS);
13975 serializer.endDocument();
13976 serializer.flush();
13977 } catch (Exception e) {
13978 if (DEBUG_BACKUP) {
13979 Slog.e(TAG, "Unable to write default apps for backup", e);
13984 return dataStream.toByteArray();
13988 public void restoreDefaultApps(byte[] backup, int userId) {
13989 if (Binder.getCallingUid() != Process.SYSTEM_UID) {
13990 throw new SecurityException("Only the system may call restoreDefaultApps()");
13994 final XmlPullParser parser = Xml.newPullParser();
13995 parser.setInput(new ByteArrayInputStream(backup), StandardCharsets.UTF_8.name());
13996 restoreFromXml(parser, userId, TAG_DEFAULT_APPS,
13997 new BlobXmlRestorer() {
13999 public void apply(XmlPullParser parser, int userId)
14000 throws XmlPullParserException, IOException {
14001 synchronized (mPackages) {
14002 mSettings.readDefaultAppsLPw(parser, userId);
14006 } catch (Exception e) {
14007 if (DEBUG_BACKUP) {
14008 Slog.e(TAG, "Exception restoring default apps: " + e.getMessage());
14014 public byte[] getIntentFilterVerificationBackup(int userId) {
14015 if (Binder.getCallingUid() != Process.SYSTEM_UID) {
14016 throw new SecurityException("Only the system may call getIntentFilterVerificationBackup()");
14019 ByteArrayOutputStream dataStream = new ByteArrayOutputStream();
14021 final XmlSerializer serializer = new FastXmlSerializer();
14022 serializer.setOutput(dataStream, StandardCharsets.UTF_8.name());
14023 serializer.startDocument(null, true);
14024 serializer.startTag(null, TAG_INTENT_FILTER_VERIFICATION);
14026 synchronized (mPackages) {
14027 mSettings.writeAllDomainVerificationsLPr(serializer, userId);
14030 serializer.endTag(null, TAG_INTENT_FILTER_VERIFICATION);
14031 serializer.endDocument();
14032 serializer.flush();
14033 } catch (Exception e) {
14034 if (DEBUG_BACKUP) {
14035 Slog.e(TAG, "Unable to write default apps for backup", e);
14040 return dataStream.toByteArray();
14044 public void restoreIntentFilterVerification(byte[] backup, int userId) {
14045 if (Binder.getCallingUid() != Process.SYSTEM_UID) {
14046 throw new SecurityException("Only the system may call restorePreferredActivities()");
14050 final XmlPullParser parser = Xml.newPullParser();
14051 parser.setInput(new ByteArrayInputStream(backup), StandardCharsets.UTF_8.name());
14052 restoreFromXml(parser, userId, TAG_INTENT_FILTER_VERIFICATION,
14053 new BlobXmlRestorer() {
14055 public void apply(XmlPullParser parser, int userId)
14056 throws XmlPullParserException, IOException {
14057 synchronized (mPackages) {
14058 mSettings.readAllDomainVerificationsLPr(parser, userId);
14059 mSettings.writeLPr();
14063 } catch (Exception e) {
14064 if (DEBUG_BACKUP) {
14065 Slog.e(TAG, "Exception restoring preferred activities: " + e.getMessage());
14071 public void addCrossProfileIntentFilter(IntentFilter intentFilter, String ownerPackage,
14072 int sourceUserId, int targetUserId, int flags) {
14073 mContext.enforceCallingOrSelfPermission(
14074 android.Manifest.permission.INTERACT_ACROSS_USERS_FULL, null);
14075 int callingUid = Binder.getCallingUid();
14076 enforceOwnerRights(ownerPackage, callingUid);
14077 enforceShellRestriction(UserManager.DISALLOW_DEBUGGING_FEATURES, callingUid, sourceUserId);
14078 if (intentFilter.countActions() == 0) {
14079 Slog.w(TAG, "Cannot set a crossProfile intent filter with no filter actions");
14082 synchronized (mPackages) {
14083 CrossProfileIntentFilter newFilter = new CrossProfileIntentFilter(intentFilter,
14084 ownerPackage, targetUserId, flags);
14085 CrossProfileIntentResolver resolver =
14086 mSettings.editCrossProfileIntentResolverLPw(sourceUserId);
14087 ArrayList<CrossProfileIntentFilter> existing = resolver.findFilters(intentFilter);
14088 // We have all those whose filter is equal. Now checking if the rest is equal as well.
14089 if (existing != null) {
14090 int size = existing.size();
14091 for (int i = 0; i < size; i++) {
14092 if (newFilter.equalsIgnoreFilter(existing.get(i))) {
14097 resolver.addFilter(newFilter);
14098 scheduleWritePackageRestrictionsLocked(sourceUserId);
14103 public void clearCrossProfileIntentFilters(int sourceUserId, String ownerPackage) {
14104 mContext.enforceCallingOrSelfPermission(
14105 android.Manifest.permission.INTERACT_ACROSS_USERS_FULL, null);
14106 int callingUid = Binder.getCallingUid();
14107 enforceOwnerRights(ownerPackage, callingUid);
14108 enforceShellRestriction(UserManager.DISALLOW_DEBUGGING_FEATURES, callingUid, sourceUserId);
14109 synchronized (mPackages) {
14110 CrossProfileIntentResolver resolver =
14111 mSettings.editCrossProfileIntentResolverLPw(sourceUserId);
14112 ArraySet<CrossProfileIntentFilter> set =
14113 new ArraySet<CrossProfileIntentFilter>(resolver.filterSet());
14114 for (CrossProfileIntentFilter filter : set) {
14115 if (filter.getOwnerPackage().equals(ownerPackage)) {
14116 resolver.removeFilter(filter);
14119 scheduleWritePackageRestrictionsLocked(sourceUserId);
14123 // Enforcing that callingUid is owning pkg on userId
14124 private void enforceOwnerRights(String pkg, int callingUid) {
14125 // The system owns everything.
14126 if (UserHandle.getAppId(callingUid) == Process.SYSTEM_UID) {
14129 int callingUserId = UserHandle.getUserId(callingUid);
14130 PackageInfo pi = getPackageInfo(pkg, 0, callingUserId);
14132 throw new IllegalArgumentException("Unknown package " + pkg + " on user "
14135 if (!UserHandle.isSameApp(pi.applicationInfo.uid, callingUid)) {
14136 throw new SecurityException("Calling uid " + callingUid
14137 + " does not own package " + pkg);
14142 public ComponentName getHomeActivities(List<ResolveInfo> allHomeCandidates) {
14143 Intent intent = new Intent(Intent.ACTION_MAIN);
14144 intent.addCategory(Intent.CATEGORY_HOME);
14146 final int callingUserId = UserHandle.getCallingUserId();
14147 List<ResolveInfo> list = queryIntentActivities(intent, null,
14148 PackageManager.GET_META_DATA, callingUserId);
14149 ResolveInfo preferred = findPreferredActivity(intent, null, 0, list, 0,
14150 true, false, false, callingUserId);
14152 allHomeCandidates.clear();
14153 if (list != null) {
14154 for (ResolveInfo ri : list) {
14155 allHomeCandidates.add(ri);
14158 return (preferred == null || preferred.activityInfo == null)
14160 : new ComponentName(preferred.activityInfo.packageName,
14161 preferred.activityInfo.name);
14165 public void setApplicationEnabledSetting(String appPackageName,
14166 int newState, int flags, int userId, String callingPackage) {
14167 if (!sUserManager.exists(userId)) return;
14168 if (callingPackage == null) {
14169 callingPackage = Integer.toString(Binder.getCallingUid());
14171 setEnabledSetting(appPackageName, null, newState, flags, userId, callingPackage);
14175 public void setComponentEnabledSetting(ComponentName componentName,
14176 int newState, int flags, int userId) {
14177 if (!sUserManager.exists(userId)) return;
14178 setEnabledSetting(componentName.getPackageName(),
14179 componentName.getClassName(), newState, flags, userId, null);
14182 private void setEnabledSetting(final String packageName, String className, int newState,
14183 final int flags, int userId, String callingPackage) {
14184 if (!(newState == COMPONENT_ENABLED_STATE_DEFAULT
14185 || newState == COMPONENT_ENABLED_STATE_ENABLED
14186 || newState == COMPONENT_ENABLED_STATE_DISABLED
14187 || newState == COMPONENT_ENABLED_STATE_DISABLED_USER
14188 || newState == COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED)) {
14189 throw new IllegalArgumentException("Invalid new component state: "
14192 PackageSetting pkgSetting;
14193 final int uid = Binder.getCallingUid();
14194 final int permission = mContext.checkCallingOrSelfPermission(
14195 android.Manifest.permission.CHANGE_COMPONENT_ENABLED_STATE);
14196 enforceCrossUserPermission(uid, userId, false, true, "set enabled");
14197 final boolean allowedByPermission = (permission == PackageManager.PERMISSION_GRANTED);
14198 boolean sendNow = false;
14199 boolean isApp = (className == null);
14200 String componentName = isApp ? packageName : className;
14201 int packageUid = -1;
14202 ArrayList<String> components;
14205 synchronized (mPackages) {
14206 pkgSetting = mSettings.mPackages.get(packageName);
14207 if (pkgSetting == null) {
14208 if (className == null) {
14209 throw new IllegalArgumentException(
14210 "Unknown package: " + packageName);
14212 throw new IllegalArgumentException(
14213 "Unknown component: " + packageName
14214 + "/" + className);
14216 // Allow root and verify that userId is not being specified by a different user
14217 if (!allowedByPermission && !UserHandle.isSameApp(uid, pkgSetting.appId)) {
14218 throw new SecurityException(
14219 "Permission Denial: attempt to change component state from pid="
14220 + Binder.getCallingPid()
14221 + ", uid=" + uid + ", package uid=" + pkgSetting.appId);
14223 if (className == null) {
14224 // We're dealing with an application/package level state change
14225 if (pkgSetting.getEnabled(userId) == newState) {
14229 if (newState == PackageManager.COMPONENT_ENABLED_STATE_DEFAULT
14230 || newState == PackageManager.COMPONENT_ENABLED_STATE_ENABLED) {
14231 // Don't care about who enables an app.
14232 callingPackage = null;
14234 pkgSetting.setEnabled(newState, userId, callingPackage);
14235 // pkgSetting.pkg.mSetEnabled = newState;
14237 // We're dealing with a component level state change
14238 // First, verify that this is a valid class name.
14239 PackageParser.Package pkg = pkgSetting.pkg;
14240 if (pkg == null || !pkg.hasComponentClassName(className)) {
14241 if (pkg.applicationInfo.targetSdkVersion >= Build.VERSION_CODES.JELLY_BEAN) {
14242 throw new IllegalArgumentException("Component class " + className
14243 + " does not exist in " + packageName);
14245 Slog.w(TAG, "Failed setComponentEnabledSetting: component class "
14246 + className + " does not exist in " + packageName);
14249 switch (newState) {
14250 case COMPONENT_ENABLED_STATE_ENABLED:
14251 if (!pkgSetting.enableComponentLPw(className, userId)) {
14255 case COMPONENT_ENABLED_STATE_DISABLED:
14256 if (!pkgSetting.disableComponentLPw(className, userId)) {
14260 case COMPONENT_ENABLED_STATE_DEFAULT:
14261 if (!pkgSetting.restoreComponentLPw(className, userId)) {
14266 Slog.e(TAG, "Invalid new component state: " + newState);
14270 scheduleWritePackageRestrictionsLocked(userId);
14271 components = mPendingBroadcasts.get(userId, packageName);
14272 final boolean newPackage = components == null;
14274 components = new ArrayList<String>();
14276 if (!components.contains(componentName)) {
14277 components.add(componentName);
14279 if ((flags&PackageManager.DONT_KILL_APP) == 0) {
14281 // Purge entry from pending broadcast list if another one exists already
14282 // since we are sending one right away.
14283 mPendingBroadcasts.remove(userId, packageName);
14286 mPendingBroadcasts.put(userId, packageName, components);
14288 if (!mHandler.hasMessages(SEND_PENDING_BROADCAST)) {
14289 // Schedule a message
14290 mHandler.sendEmptyMessageDelayed(SEND_PENDING_BROADCAST, BROADCAST_DELAY);
14295 long callingId = Binder.clearCallingIdentity();
14298 packageUid = UserHandle.getUid(userId, pkgSetting.appId);
14299 sendPackageChangedBroadcast(packageName,
14300 (flags&PackageManager.DONT_KILL_APP) != 0, components, packageUid);
14303 Binder.restoreCallingIdentity(callingId);
14307 private void sendPackageChangedBroadcast(String packageName,
14308 boolean killFlag, ArrayList<String> componentNames, int packageUid) {
14310 Log.v(TAG, "Sending package changed: package=" + packageName + " components="
14312 Bundle extras = new Bundle(4);
14313 extras.putString(Intent.EXTRA_CHANGED_COMPONENT_NAME, componentNames.get(0));
14314 String nameList[] = new String[componentNames.size()];
14315 componentNames.toArray(nameList);
14316 extras.putStringArray(Intent.EXTRA_CHANGED_COMPONENT_NAME_LIST, nameList);
14317 extras.putBoolean(Intent.EXTRA_DONT_KILL_APP, killFlag);
14318 extras.putInt(Intent.EXTRA_UID, packageUid);
14319 sendPackageBroadcast(Intent.ACTION_PACKAGE_CHANGED, packageName, extras, null, null,
14320 new int[] {UserHandle.getUserId(packageUid)});
14324 public void setPackageStoppedState(String packageName, boolean stopped, int userId) {
14325 if (!sUserManager.exists(userId)) return;
14326 final int uid = Binder.getCallingUid();
14327 final int permission = mContext.checkCallingOrSelfPermission(
14328 android.Manifest.permission.CHANGE_COMPONENT_ENABLED_STATE);
14329 final boolean allowedByPermission = (permission == PackageManager.PERMISSION_GRANTED);
14330 enforceCrossUserPermission(uid, userId, true, true, "stop package");
14332 synchronized (mPackages) {
14333 if (mSettings.setPackageStoppedStateLPw(this, packageName, stopped,
14334 allowedByPermission, uid, userId)) {
14335 scheduleWritePackageRestrictionsLocked(userId);
14341 public String getInstallerPackageName(String packageName) {
14343 synchronized (mPackages) {
14344 return mSettings.getInstallerPackageNameLPr(packageName);
14349 public int getApplicationEnabledSetting(String packageName, int userId) {
14350 if (!sUserManager.exists(userId)) return COMPONENT_ENABLED_STATE_DISABLED;
14351 int uid = Binder.getCallingUid();
14352 enforceCrossUserPermission(uid, userId, false, false, "get enabled");
14354 synchronized (mPackages) {
14355 return mSettings.getApplicationEnabledSettingLPr(packageName, userId);
14360 public int getComponentEnabledSetting(ComponentName componentName, int userId) {
14361 if (!sUserManager.exists(userId)) return COMPONENT_ENABLED_STATE_DISABLED;
14362 int uid = Binder.getCallingUid();
14363 enforceCrossUserPermission(uid, userId, false, false, "get component enabled");
14365 synchronized (mPackages) {
14366 return mSettings.getComponentEnabledSettingLPr(componentName, userId);
14371 public void enterSafeMode() {
14372 enforceSystemOrRoot("Only the system can request entering safe mode");
14374 if (!mSystemReady) {
14380 public void systemReady() {
14381 mSystemReady = true;
14383 // Read the compatibilty setting when the system is ready.
14384 boolean compatibilityModeEnabled = android.provider.Settings.Global.getInt(
14385 mContext.getContentResolver(),
14386 android.provider.Settings.Global.COMPATIBILITY_MODE, 1) == 1;
14387 PackageParser.setCompatibilityModeEnabled(compatibilityModeEnabled);
14388 if (DEBUG_SETTINGS) {
14389 Log.d(TAG, "compatibility mode:" + compatibilityModeEnabled);
14392 int[] grantPermissionsUserIds = EMPTY_INT_ARRAY;
14394 synchronized (mPackages) {
14395 // Verify that all of the preferred activity components actually
14396 // exist. It is possible for applications to be updated and at
14397 // that point remove a previously declared activity component that
14398 // had been set as a preferred activity. We try to clean this up
14399 // the next time we encounter that preferred activity, but it is
14400 // possible for the user flow to never be able to return to that
14401 // situation so here we do a sanity check to make sure we haven't
14402 // left any junk around.
14403 ArrayList<PreferredActivity> removed = new ArrayList<PreferredActivity>();
14404 for (int i=0; i<mSettings.mPreferredActivities.size(); i++) {
14405 PreferredIntentResolver pir = mSettings.mPreferredActivities.valueAt(i);
14407 for (PreferredActivity pa : pir.filterSet()) {
14408 if (mActivities.mActivities.get(pa.mPref.mComponent) == null) {
14412 if (removed.size() > 0) {
14413 for (int r=0; r<removed.size(); r++) {
14414 PreferredActivity pa = removed.get(r);
14415 Slog.w(TAG, "Removing dangling preferred activity: "
14416 + pa.mPref.mComponent);
14417 pir.removeFilter(pa);
14419 mSettings.writePackageRestrictionsLPr(
14420 mSettings.mPreferredActivities.keyAt(i));
14424 for (int userId : UserManagerService.getInstance().getUserIds()) {
14425 if (!mSettings.areDefaultRuntimePermissionsGrantedLPr(userId)) {
14426 grantPermissionsUserIds = ArrayUtils.appendInt(
14427 grantPermissionsUserIds, userId);
14431 sUserManager.systemReady();
14433 // If we upgraded grant all default permissions before kicking off.
14434 for (int userId : grantPermissionsUserIds) {
14435 mDefaultPermissionPolicy.grantDefaultPermissions(userId);
14438 // Kick off any messages waiting for system ready
14439 if (mPostSystemReadyMessages != null) {
14440 for (Message msg : mPostSystemReadyMessages) {
14441 msg.sendToTarget();
14443 mPostSystemReadyMessages = null;
14446 // Watch for external volumes that come and go over time
14447 final StorageManager storage = mContext.getSystemService(StorageManager.class);
14448 storage.registerListener(mStorageListener);
14450 mInstallerService.systemReady();
14451 mPackageDexOptimizer.systemReady();
14455 public boolean isSafeMode() {
14460 public boolean hasSystemUidErrors() {
14461 return mHasSystemUidErrors;
14464 static String arrayToString(int[] array) {
14465 StringBuffer buf = new StringBuffer(128);
14467 if (array != null) {
14468 for (int i=0; i<array.length; i++) {
14469 if (i > 0) buf.append(", ");
14470 buf.append(array[i]);
14474 return buf.toString();
14477 static class DumpState {
14478 public static final int DUMP_LIBS = 1 << 0;
14479 public static final int DUMP_FEATURES = 1 << 1;
14480 public static final int DUMP_RESOLVERS = 1 << 2;
14481 public static final int DUMP_PERMISSIONS = 1 << 3;
14482 public static final int DUMP_PACKAGES = 1 << 4;
14483 public static final int DUMP_SHARED_USERS = 1 << 5;
14484 public static final int DUMP_MESSAGES = 1 << 6;
14485 public static final int DUMP_PROVIDERS = 1 << 7;
14486 public static final int DUMP_VERIFIERS = 1 << 8;
14487 public static final int DUMP_PREFERRED = 1 << 9;
14488 public static final int DUMP_PREFERRED_XML = 1 << 10;
14489 public static final int DUMP_KEYSETS = 1 << 11;
14490 public static final int DUMP_VERSION = 1 << 12;
14491 public static final int DUMP_INSTALLS = 1 << 13;
14492 public static final int DUMP_INTENT_FILTER_VERIFIERS = 1 << 14;
14493 public static final int DUMP_DOMAIN_PREFERRED = 1 << 15;
14495 public static final int OPTION_SHOW_FILTERS = 1 << 0;
14497 private int mTypes;
14499 private int mOptions;
14501 private boolean mTitlePrinted;
14503 private SharedUserSetting mSharedUser;
14505 public boolean isDumping(int type) {
14506 if (mTypes == 0 && type != DUMP_PREFERRED_XML) {
14510 return (mTypes & type) != 0;
14513 public void setDump(int type) {
14517 public boolean isOptionEnabled(int option) {
14518 return (mOptions & option) != 0;
14521 public void setOptionEnabled(int option) {
14522 mOptions |= option;
14525 public boolean onTitlePrinted() {
14526 final boolean printed = mTitlePrinted;
14527 mTitlePrinted = true;
14531 public boolean getTitlePrinted() {
14532 return mTitlePrinted;
14535 public void setTitlePrinted(boolean enabled) {
14536 mTitlePrinted = enabled;
14539 public SharedUserSetting getSharedUser() {
14540 return mSharedUser;
14543 public void setSharedUser(SharedUserSetting user) {
14544 mSharedUser = user;
14549 protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
14550 if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DUMP)
14551 != PackageManager.PERMISSION_GRANTED) {
14552 pw.println("Permission Denial: can't dump ActivityManager from from pid="
14553 + Binder.getCallingPid()
14554 + ", uid=" + Binder.getCallingUid()
14555 + " without permission "
14556 + android.Manifest.permission.DUMP);
14560 DumpState dumpState = new DumpState();
14561 boolean fullPreferred = false;
14562 boolean checkin = false;
14564 String packageName = null;
14565 ArraySet<String> permissionNames = null;
14568 while (opti < args.length) {
14569 String opt = args[opti];
14570 if (opt == null || opt.length() <= 0 || opt.charAt(0) != '-') {
14575 if ("-a".equals(opt)) {
14576 // Right now we only know how to print all.
14577 } else if ("-h".equals(opt)) {
14578 pw.println("Package manager dump options:");
14579 pw.println(" [-h] [-f] [--checkin] [cmd] ...");
14580 pw.println(" --checkin: dump for a checkin");
14581 pw.println(" -f: print details of intent filters");
14582 pw.println(" -h: print this help");
14583 pw.println(" cmd may be one of:");
14584 pw.println(" l[ibraries]: list known shared libraries");
14585 pw.println(" f[ibraries]: list device features");
14586 pw.println(" k[eysets]: print known keysets");
14587 pw.println(" r[esolvers]: dump intent resolvers");
14588 pw.println(" perm[issions]: dump permissions");
14589 pw.println(" permission [name ...]: dump declaration and use of given permission");
14590 pw.println(" pref[erred]: print preferred package settings");
14591 pw.println(" preferred-xml [--full]: print preferred package settings as xml");
14592 pw.println(" prov[iders]: dump content providers");
14593 pw.println(" p[ackages]: dump installed packages");
14594 pw.println(" s[hared-users]: dump shared user IDs");
14595 pw.println(" m[essages]: print collected runtime messages");
14596 pw.println(" v[erifiers]: print package verifier info");
14597 pw.println(" version: print database version info");
14598 pw.println(" write: write current settings now");
14599 pw.println(" <package.name>: info about given package");
14600 pw.println(" installs: details about install sessions");
14601 pw.println(" d[omain-preferred-apps]: print domains preferred apps");
14602 pw.println(" i[ntent-filter-verifiers]|ifv: print intent filter verifier info");
14604 } else if ("--checkin".equals(opt)) {
14606 } else if ("-f".equals(opt)) {
14607 dumpState.setOptionEnabled(DumpState.OPTION_SHOW_FILTERS);
14609 pw.println("Unknown argument: " + opt + "; use -h for help");
14613 // Is the caller requesting to dump a particular piece of data?
14614 if (opti < args.length) {
14615 String cmd = args[opti];
14617 // Is this a package name?
14618 if ("android".equals(cmd) || cmd.contains(".")) {
14620 // When dumping a single package, we always dump all of its
14621 // filter information since the amount of data will be reasonable.
14622 dumpState.setOptionEnabled(DumpState.OPTION_SHOW_FILTERS);
14623 } else if ("l".equals(cmd) || "libraries".equals(cmd)) {
14624 dumpState.setDump(DumpState.DUMP_LIBS);
14625 } else if ("f".equals(cmd) || "features".equals(cmd)) {
14626 dumpState.setDump(DumpState.DUMP_FEATURES);
14627 } else if ("r".equals(cmd) || "resolvers".equals(cmd)) {
14628 dumpState.setDump(DumpState.DUMP_RESOLVERS);
14629 } else if ("perm".equals(cmd) || "permissions".equals(cmd)) {
14630 dumpState.setDump(DumpState.DUMP_PERMISSIONS);
14631 } else if ("permission".equals(cmd)) {
14632 if (opti >= args.length) {
14633 pw.println("Error: permission requires permission name");
14636 permissionNames = new ArraySet<>();
14637 while (opti < args.length) {
14638 permissionNames.add(args[opti]);
14641 dumpState.setDump(DumpState.DUMP_PERMISSIONS
14642 | DumpState.DUMP_PACKAGES | DumpState.DUMP_SHARED_USERS);
14643 } else if ("pref".equals(cmd) || "preferred".equals(cmd)) {
14644 dumpState.setDump(DumpState.DUMP_PREFERRED);
14645 } else if ("preferred-xml".equals(cmd)) {
14646 dumpState.setDump(DumpState.DUMP_PREFERRED_XML);
14647 if (opti < args.length && "--full".equals(args[opti])) {
14648 fullPreferred = true;
14651 } else if ("d".equals(cmd) || "domain-preferred-apps".equals(cmd)) {
14652 dumpState.setDump(DumpState.DUMP_DOMAIN_PREFERRED);
14653 } else if ("p".equals(cmd) || "packages".equals(cmd)) {
14654 dumpState.setDump(DumpState.DUMP_PACKAGES);
14655 } else if ("s".equals(cmd) || "shared-users".equals(cmd)) {
14656 dumpState.setDump(DumpState.DUMP_SHARED_USERS);
14657 } else if ("prov".equals(cmd) || "providers".equals(cmd)) {
14658 dumpState.setDump(DumpState.DUMP_PROVIDERS);
14659 } else if ("m".equals(cmd) || "messages".equals(cmd)) {
14660 dumpState.setDump(DumpState.DUMP_MESSAGES);
14661 } else if ("v".equals(cmd) || "verifiers".equals(cmd)) {
14662 dumpState.setDump(DumpState.DUMP_VERIFIERS);
14663 } else if ("i".equals(cmd) || "ifv".equals(cmd)
14664 || "intent-filter-verifiers".equals(cmd)) {
14665 dumpState.setDump(DumpState.DUMP_INTENT_FILTER_VERIFIERS);
14666 } else if ("version".equals(cmd)) {
14667 dumpState.setDump(DumpState.DUMP_VERSION);
14668 } else if ("k".equals(cmd) || "keysets".equals(cmd)) {
14669 dumpState.setDump(DumpState.DUMP_KEYSETS);
14670 } else if ("installs".equals(cmd)) {
14671 dumpState.setDump(DumpState.DUMP_INSTALLS);
14672 } else if ("write".equals(cmd)) {
14673 synchronized (mPackages) {
14674 mSettings.writeLPr();
14675 pw.println("Settings written.");
14682 pw.println("vers,1");
14686 synchronized (mPackages) {
14687 if (dumpState.isDumping(DumpState.DUMP_VERSION) && packageName == null) {
14689 if (dumpState.onTitlePrinted())
14691 pw.println("Database versions:");
14692 pw.print(" SDK Version:");
14693 pw.print(" internal=");
14694 pw.print(mSettings.mInternalSdkPlatform);
14695 pw.print(" external=");
14696 pw.println(mSettings.mExternalSdkPlatform);
14697 pw.print(" DB Version:");
14698 pw.print(" internal=");
14699 pw.print(mSettings.mInternalDatabaseVersion);
14700 pw.print(" external=");
14701 pw.println(mSettings.mExternalDatabaseVersion);
14705 if (dumpState.isDumping(DumpState.DUMP_VERIFIERS) && packageName == null) {
14707 if (dumpState.onTitlePrinted())
14709 pw.println("Verifiers:");
14710 pw.print(" Required: ");
14711 pw.print(mRequiredVerifierPackage);
14712 pw.print(" (uid=");
14713 pw.print(getPackageUid(mRequiredVerifierPackage, 0));
14715 } else if (mRequiredVerifierPackage != null) {
14716 pw.print("vrfy,"); pw.print(mRequiredVerifierPackage);
14717 pw.print(","); pw.println(getPackageUid(mRequiredVerifierPackage, 0));
14721 if (dumpState.isDumping(DumpState.DUMP_INTENT_FILTER_VERIFIERS) &&
14722 packageName == null) {
14723 if (mIntentFilterVerifierComponent != null) {
14724 String verifierPackageName = mIntentFilterVerifierComponent.getPackageName();
14726 if (dumpState.onTitlePrinted())
14728 pw.println("Intent Filter Verifier:");
14729 pw.print(" Using: ");
14730 pw.print(verifierPackageName);
14731 pw.print(" (uid=");
14732 pw.print(getPackageUid(verifierPackageName, 0));
14734 } else if (verifierPackageName != null) {
14735 pw.print("ifv,"); pw.print(verifierPackageName);
14736 pw.print(","); pw.println(getPackageUid(verifierPackageName, 0));
14740 pw.println("No Intent Filter Verifier available!");
14744 if (dumpState.isDumping(DumpState.DUMP_LIBS) && packageName == null) {
14745 boolean printedHeader = false;
14746 final Iterator<String> it = mSharedLibraries.keySet().iterator();
14747 while (it.hasNext()) {
14748 String name = it.next();
14749 SharedLibraryEntry ent = mSharedLibraries.get(name);
14751 if (!printedHeader) {
14752 if (dumpState.onTitlePrinted())
14754 pw.println("Libraries:");
14755 printedHeader = true;
14765 if (ent.path != null) {
14767 pw.print("(jar) ");
14768 pw.print(ent.path);
14771 pw.print(ent.path);
14775 pw.print("(apk) ");
14786 if (dumpState.isDumping(DumpState.DUMP_FEATURES) && packageName == null) {
14787 if (dumpState.onTitlePrinted())
14790 pw.println("Features:");
14792 Iterator<String> it = mAvailableFeatures.keySet().iterator();
14793 while (it.hasNext()) {
14794 String name = it.next();
14804 if (!checkin && dumpState.isDumping(DumpState.DUMP_RESOLVERS)) {
14805 if (mActivities.dump(pw, dumpState.getTitlePrinted() ? "\nActivity Resolver Table:"
14806 : "Activity Resolver Table:", " ", packageName,
14807 dumpState.isOptionEnabled(DumpState.OPTION_SHOW_FILTERS), true)) {
14808 dumpState.setTitlePrinted(true);
14810 if (mReceivers.dump(pw, dumpState.getTitlePrinted() ? "\nReceiver Resolver Table:"
14811 : "Receiver Resolver Table:", " ", packageName,
14812 dumpState.isOptionEnabled(DumpState.OPTION_SHOW_FILTERS), true)) {
14813 dumpState.setTitlePrinted(true);
14815 if (mServices.dump(pw, dumpState.getTitlePrinted() ? "\nService Resolver Table:"
14816 : "Service Resolver Table:", " ", packageName,
14817 dumpState.isOptionEnabled(DumpState.OPTION_SHOW_FILTERS), true)) {
14818 dumpState.setTitlePrinted(true);
14820 if (mProviders.dump(pw, dumpState.getTitlePrinted() ? "\nProvider Resolver Table:"
14821 : "Provider Resolver Table:", " ", packageName,
14822 dumpState.isOptionEnabled(DumpState.OPTION_SHOW_FILTERS), true)) {
14823 dumpState.setTitlePrinted(true);
14827 if (!checkin && dumpState.isDumping(DumpState.DUMP_PREFERRED)) {
14828 for (int i=0; i<mSettings.mPreferredActivities.size(); i++) {
14829 PreferredIntentResolver pir = mSettings.mPreferredActivities.valueAt(i);
14830 int user = mSettings.mPreferredActivities.keyAt(i);
14832 dumpState.getTitlePrinted()
14833 ? "\nPreferred Activities User " + user + ":"
14834 : "Preferred Activities User " + user + ":", " ",
14835 packageName, true, false)) {
14836 dumpState.setTitlePrinted(true);
14841 if (!checkin && dumpState.isDumping(DumpState.DUMP_PREFERRED_XML)) {
14843 FileOutputStream fout = new FileOutputStream(fd);
14844 BufferedOutputStream str = new BufferedOutputStream(fout);
14845 XmlSerializer serializer = new FastXmlSerializer();
14847 serializer.setOutput(str, StandardCharsets.UTF_8.name());
14848 serializer.startDocument(null, true);
14849 serializer.setFeature(
14850 "http://xmlpull.org/v1/doc/features.html#indent-output", true);
14851 mSettings.writePreferredActivitiesLPr(serializer, 0, fullPreferred);
14852 serializer.endDocument();
14853 serializer.flush();
14854 } catch (IllegalArgumentException e) {
14855 pw.println("Failed writing: " + e);
14856 } catch (IllegalStateException e) {
14857 pw.println("Failed writing: " + e);
14858 } catch (IOException e) {
14859 pw.println("Failed writing: " + e);
14864 && dumpState.isDumping(DumpState.DUMP_DOMAIN_PREFERRED)
14865 && packageName == null) {
14867 int count = mSettings.mPackages.size();
14869 pw.println("No applications!");
14872 final String prefix = " ";
14873 Collection<PackageSetting> allPackageSettings = mSettings.mPackages.values();
14874 if (allPackageSettings.size() == 0) {
14875 pw.println("No domain preferred apps!");
14878 pw.println("App verification status:");
14881 for (PackageSetting ps : allPackageSettings) {
14882 IntentFilterVerificationInfo ivi = ps.getIntentFilterVerificationInfo();
14883 if (ivi == null || ivi.getPackageName() == null) continue;
14884 pw.println(prefix + "Package: " + ivi.getPackageName());
14885 pw.println(prefix + "Domains: " + ivi.getDomainsString());
14886 pw.println(prefix + "Status: " + ivi.getStatusString());
14891 pw.println(prefix + "No app verification established.");
14894 for (int userId : sUserManager.getUserIds()) {
14895 pw.println("App linkages for user " + userId + ":");
14898 for (PackageSetting ps : allPackageSettings) {
14899 final long status = ps.getDomainVerificationStatusForUser(userId);
14900 if (status >> 32 == INTENT_FILTER_DOMAIN_VERIFICATION_STATUS_UNDEFINED) {
14903 pw.println(prefix + "Package: " + ps.name);
14904 pw.println(prefix + "Domains: " + dumpDomainString(ps.name));
14905 String statusStr = IntentFilterVerificationInfo.
14906 getStatusStringFromValue(status);
14907 pw.println(prefix + "Status: " + statusStr);
14912 pw.println(prefix + "No configured app linkages.");
14920 if (!checkin && dumpState.isDumping(DumpState.DUMP_PERMISSIONS)) {
14921 mSettings.dumpPermissionsLPr(pw, packageName, permissionNames, dumpState);
14922 if (packageName == null && permissionNames == null) {
14923 for (int iperm=0; iperm<mAppOpPermissionPackages.size(); iperm++) {
14925 if (dumpState.onTitlePrinted())
14927 pw.println("AppOp Permissions:");
14929 pw.print(" AppOp Permission ");
14930 pw.print(mAppOpPermissionPackages.keyAt(iperm));
14932 ArraySet<String> pkgs = mAppOpPermissionPackages.valueAt(iperm);
14933 for (int ipkg=0; ipkg<pkgs.size(); ipkg++) {
14934 pw.print(" "); pw.println(pkgs.valueAt(ipkg));
14940 if (!checkin && dumpState.isDumping(DumpState.DUMP_PROVIDERS)) {
14941 boolean printedSomething = false;
14942 for (PackageParser.Provider p : mProviders.mProviders.values()) {
14943 if (packageName != null && !packageName.equals(p.info.packageName)) {
14946 if (!printedSomething) {
14947 if (dumpState.onTitlePrinted())
14949 pw.println("Registered ContentProviders:");
14950 printedSomething = true;
14952 pw.print(" "); p.printComponentShortName(pw); pw.println(":");
14953 pw.print(" "); pw.println(p.toString());
14955 printedSomething = false;
14956 for (Map.Entry<String, PackageParser.Provider> entry :
14957 mProvidersByAuthority.entrySet()) {
14958 PackageParser.Provider p = entry.getValue();
14959 if (packageName != null && !packageName.equals(p.info.packageName)) {
14962 if (!printedSomething) {
14963 if (dumpState.onTitlePrinted())
14965 pw.println("ContentProvider Authorities:");
14966 printedSomething = true;
14968 pw.print(" ["); pw.print(entry.getKey()); pw.println("]:");
14969 pw.print(" "); pw.println(p.toString());
14970 if (p.info != null && p.info.applicationInfo != null) {
14971 final String appInfo = p.info.applicationInfo.toString();
14972 pw.print(" applicationInfo="); pw.println(appInfo);
14977 if (!checkin && dumpState.isDumping(DumpState.DUMP_KEYSETS)) {
14978 mSettings.mKeySetManagerService.dumpLPr(pw, packageName, dumpState);
14981 if (dumpState.isDumping(DumpState.DUMP_PACKAGES)) {
14982 mSettings.dumpPackagesLPr(pw, packageName, permissionNames, dumpState, checkin);
14985 if (dumpState.isDumping(DumpState.DUMP_SHARED_USERS)) {
14986 mSettings.dumpSharedUsersLPr(pw, packageName, permissionNames, dumpState, checkin);
14989 if (!checkin && dumpState.isDumping(DumpState.DUMP_INSTALLS) && packageName == null) {
14990 // XXX should handle packageName != null by dumping only install data that
14991 // the given package is involved with.
14992 if (dumpState.onTitlePrinted()) pw.println();
14993 mInstallerService.dump(new IndentingPrintWriter(pw, " ", 120));
14996 if (!checkin && dumpState.isDumping(DumpState.DUMP_MESSAGES) && packageName == null) {
14997 if (dumpState.onTitlePrinted()) pw.println();
14998 mSettings.dumpReadMessagesLPr(pw, dumpState);
15001 pw.println("Package warning messages:");
15002 BufferedReader in = null;
15003 String line = null;
15005 in = new BufferedReader(new FileReader(getSettingsProblemFile()));
15006 while ((line = in.readLine()) != null) {
15007 if (line.contains("ignored: updated version")) continue;
15010 } catch (IOException ignored) {
15012 IoUtils.closeQuietly(in);
15016 if (checkin && dumpState.isDumping(DumpState.DUMP_MESSAGES)) {
15017 BufferedReader in = null;
15018 String line = null;
15020 in = new BufferedReader(new FileReader(getSettingsProblemFile()));
15021 while ((line = in.readLine()) != null) {
15022 if (line.contains("ignored: updated version")) continue;
15026 } catch (IOException ignored) {
15028 IoUtils.closeQuietly(in);
15034 private String dumpDomainString(String packageName) {
15035 List<IntentFilterVerificationInfo> iviList = getIntentFilterVerifications(packageName);
15036 List<IntentFilter> filters = getAllIntentFilters(packageName);
15038 ArraySet<String> result = new ArraySet<>();
15039 if (iviList.size() > 0) {
15040 for (IntentFilterVerificationInfo ivi : iviList) {
15041 for (String host : ivi.getDomains()) {
15046 if (filters != null && filters.size() > 0) {
15047 for (IntentFilter filter : filters) {
15048 if (filter.hasDataScheme(IntentFilter.SCHEME_HTTP) ||
15049 filter.hasDataScheme(IntentFilter.SCHEME_HTTPS)) {
15050 result.addAll(filter.getHostsList());
15055 StringBuilder sb = new StringBuilder(result.size() * 16);
15056 for (String domain : result) {
15057 if (sb.length() > 0) sb.append(" ");
15060 return sb.toString();
15063 // ------- apps on sdcard specific code -------
15064 static final boolean DEBUG_SD_INSTALL = false;
15066 private static final String SD_ENCRYPTION_KEYSTORE_NAME = "AppsOnSD";
15068 private static final String SD_ENCRYPTION_ALGORITHM = "AES";
15070 private boolean mMediaMounted = false;
15072 static String getEncryptKey() {
15074 String sdEncKey = SystemKeyStore.getInstance().retrieveKeyHexString(
15075 SD_ENCRYPTION_KEYSTORE_NAME);
15076 if (sdEncKey == null) {
15077 sdEncKey = SystemKeyStore.getInstance().generateNewKeyHexString(128,
15078 SD_ENCRYPTION_ALGORITHM, SD_ENCRYPTION_KEYSTORE_NAME);
15079 if (sdEncKey == null) {
15080 Slog.e(TAG, "Failed to create encryption keys");
15085 } catch (NoSuchAlgorithmException nsae) {
15086 Slog.e(TAG, "Failed to create encryption keys with exception: " + nsae);
15088 } catch (IOException ioe) {
15089 Slog.e(TAG, "Failed to retrieve encryption keys with exception: " + ioe);
15095 * Update media status on PackageManager.
15098 public void updateExternalMediaStatus(final boolean mediaStatus, final boolean reportStatus) {
15099 int callingUid = Binder.getCallingUid();
15100 if (callingUid != 0 && callingUid != Process.SYSTEM_UID) {
15101 throw new SecurityException("Media status can only be updated by the system");
15103 // reader; this apparently protects mMediaMounted, but should probably
15104 // be a different lock in that case.
15105 synchronized (mPackages) {
15106 Log.i(TAG, "Updating external media status from "
15107 + (mMediaMounted ? "mounted" : "unmounted") + " to "
15108 + (mediaStatus ? "mounted" : "unmounted"));
15109 if (DEBUG_SD_INSTALL)
15110 Log.i(TAG, "updateExternalMediaStatus:: mediaStatus=" + mediaStatus
15111 + ", mMediaMounted=" + mMediaMounted);
15112 if (mediaStatus == mMediaMounted) {
15113 final Message msg = mHandler.obtainMessage(UPDATED_MEDIA_STATUS, reportStatus ? 1
15115 mHandler.sendMessage(msg);
15118 mMediaMounted = mediaStatus;
15120 // Queue up an async operation since the package installation may take a
15122 mHandler.post(new Runnable() {
15123 public void run() {
15124 updateExternalMediaStatusInner(mediaStatus, reportStatus, true);
15130 * Called by MountService when the initial ASECs to scan are available.
15131 * Should block until all the ASEC containers are finished being scanned.
15133 public void scanAvailableAsecs() {
15134 updateExternalMediaStatusInner(true, false, false);
15135 if (mShouldRestoreconData) {
15136 SELinuxMMAC.setRestoreconDone();
15137 mShouldRestoreconData = false;
15142 * Collect information of applications on external media, map them against
15143 * existing containers and update information based on current mount status.
15144 * Please note that we always have to report status if reportStatus has been
15145 * set to true especially when unloading packages.
15147 private void updateExternalMediaStatusInner(boolean isMounted, boolean reportStatus,
15148 boolean externalStorage) {
15149 ArrayMap<AsecInstallArgs, String> processCids = new ArrayMap<>();
15150 int[] uidArr = EmptyArray.INT;
15152 final String[] list = PackageHelper.getSecureContainerList();
15153 if (ArrayUtils.isEmpty(list)) {
15154 Log.i(TAG, "No secure containers found");
15156 // Process list of secure containers and categorize them
15157 // as active or stale based on their package internal state.
15160 synchronized (mPackages) {
15161 for (String cid : list) {
15162 // Leave stages untouched for now; installer service owns them
15163 if (PackageInstallerService.isStageName(cid)) continue;
15165 if (DEBUG_SD_INSTALL)
15166 Log.i(TAG, "Processing container " + cid);
15167 String pkgName = getAsecPackageName(cid);
15168 if (pkgName == null) {
15169 Slog.i(TAG, "Found stale container " + cid + " with no package name");
15172 if (DEBUG_SD_INSTALL)
15173 Log.i(TAG, "Looking for pkg : " + pkgName);
15175 final PackageSetting ps = mSettings.mPackages.get(pkgName);
15177 Slog.i(TAG, "Found stale container " + cid + " with no matching settings");
15182 * Skip packages that are not external if we're unmounting
15183 * external storage.
15185 if (externalStorage && !isMounted && !isExternal(ps)) {
15189 final AsecInstallArgs args = new AsecInstallArgs(cid,
15190 getAppDexInstructionSets(ps), ps.isForwardLocked());
15191 // The package status is changed only if the code path
15192 // matches between settings and the container id.
15193 if (ps.codePathString != null
15194 && ps.codePathString.startsWith(args.getCodePath())) {
15195 if (DEBUG_SD_INSTALL) {
15196 Log.i(TAG, "Container : " + cid + " corresponds to pkg : " + pkgName
15197 + " at code path: " + ps.codePathString);
15200 // We do have a valid package installed on sdcard
15201 processCids.put(args, ps.codePathString);
15202 final int uid = ps.appId;
15204 uidArr = ArrayUtils.appendInt(uidArr, uid);
15207 Slog.i(TAG, "Found stale container " + cid + ": expected codePath="
15208 + ps.codePathString);
15213 Arrays.sort(uidArr);
15216 // Process packages with valid entries.
15218 if (DEBUG_SD_INSTALL)
15219 Log.i(TAG, "Loading packages");
15220 loadMediaPackages(processCids, uidArr);
15221 startCleaningPackages();
15222 mInstallerService.onSecureContainersAvailable();
15224 if (DEBUG_SD_INSTALL)
15225 Log.i(TAG, "Unloading packages");
15226 unloadMediaPackages(processCids, uidArr, reportStatus);
15230 private void sendResourcesChangedBroadcast(boolean mediaStatus, boolean replacing,
15231 ArrayList<ApplicationInfo> infos, IIntentReceiver finishedReceiver) {
15232 final int size = infos.size();
15233 final String[] packageNames = new String[size];
15234 final int[] packageUids = new int[size];
15235 for (int i = 0; i < size; i++) {
15236 final ApplicationInfo info = infos.get(i);
15237 packageNames[i] = info.packageName;
15238 packageUids[i] = info.uid;
15240 sendResourcesChangedBroadcast(mediaStatus, replacing, packageNames, packageUids,
15244 private void sendResourcesChangedBroadcast(boolean mediaStatus, boolean replacing,
15245 ArrayList<String> pkgList, int uidArr[], IIntentReceiver finishedReceiver) {
15246 sendResourcesChangedBroadcast(mediaStatus, replacing,
15247 pkgList.toArray(new String[pkgList.size()]), uidArr, finishedReceiver);
15250 private void sendResourcesChangedBroadcast(boolean mediaStatus, boolean replacing,
15251 String[] pkgList, int uidArr[], IIntentReceiver finishedReceiver) {
15252 int size = pkgList.length;
15254 // Send broadcasts here
15255 Bundle extras = new Bundle();
15256 extras.putStringArray(Intent.EXTRA_CHANGED_PACKAGE_LIST, pkgList);
15257 if (uidArr != null) {
15258 extras.putIntArray(Intent.EXTRA_CHANGED_UID_LIST, uidArr);
15261 extras.putBoolean(Intent.EXTRA_REPLACING, replacing);
15263 String action = mediaStatus ? Intent.ACTION_EXTERNAL_APPLICATIONS_AVAILABLE
15264 : Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE;
15265 sendPackageBroadcast(action, null, extras, null, finishedReceiver, null);
15270 * Look at potentially valid container ids from processCids If package
15271 * information doesn't match the one on record or package scanning fails,
15272 * the cid is added to list of removeCids. We currently don't delete stale
15275 private void loadMediaPackages(ArrayMap<AsecInstallArgs, String> processCids, int[] uidArr) {
15276 ArrayList<String> pkgList = new ArrayList<String>();
15277 Set<AsecInstallArgs> keys = processCids.keySet();
15279 for (AsecInstallArgs args : keys) {
15280 String codePath = processCids.get(args);
15281 if (DEBUG_SD_INSTALL)
15282 Log.i(TAG, "Loading container : " + args.cid);
15283 int retCode = PackageManager.INSTALL_FAILED_CONTAINER_ERROR;
15285 // Make sure there are no container errors first.
15286 if (args.doPreInstall(PackageManager.INSTALL_SUCCEEDED) != PackageManager.INSTALL_SUCCEEDED) {
15287 Slog.e(TAG, "Failed to mount cid : " + args.cid
15288 + " when installing from sdcard");
15291 // Check code path here.
15292 if (codePath == null || !codePath.startsWith(args.getCodePath())) {
15293 Slog.e(TAG, "Container " + args.cid + " cachepath " + args.getCodePath()
15294 + " does not match one in settings " + codePath);
15298 int parseFlags = mDefParseFlags;
15299 if (args.isExternalAsec()) {
15300 parseFlags |= PackageParser.PARSE_EXTERNAL_STORAGE;
15302 if (args.isFwdLocked()) {
15303 parseFlags |= PackageParser.PARSE_FORWARD_LOCK;
15306 synchronized (mInstallLock) {
15307 PackageParser.Package pkg = null;
15309 pkg = scanPackageLI(new File(codePath), parseFlags, 0, 0, null);
15310 } catch (PackageManagerException e) {
15311 Slog.w(TAG, "Failed to scan " + codePath + ": " + e.getMessage());
15313 // Scan the package
15316 * TODO why is the lock being held? doPostInstall is
15317 * called in other places without the lock. This needs
15318 * to be straightened out.
15321 synchronized (mPackages) {
15322 retCode = PackageManager.INSTALL_SUCCEEDED;
15323 pkgList.add(pkg.packageName);
15324 // Post process args
15325 args.doPostInstall(PackageManager.INSTALL_SUCCEEDED,
15326 pkg.applicationInfo.uid);
15329 Slog.i(TAG, "Failed to install pkg from " + codePath + " from sdcard");
15334 if (retCode != PackageManager.INSTALL_SUCCEEDED) {
15335 Log.w(TAG, "Container " + args.cid + " is stale, retCode=" + retCode);
15340 synchronized (mPackages) {
15341 // If the platform SDK has changed since the last time we booted,
15342 // we need to re-grant app permission to catch any new ones that
15343 // appear. This is really a hack, and means that apps can in some
15344 // cases get permissions that the user didn't initially explicitly
15345 // allow... it would be nice to have some better way to handle
15347 final boolean regrantPermissions = mSettings.mExternalSdkPlatform != mSdkVersion;
15348 if (regrantPermissions)
15349 Slog.i(TAG, "Platform changed from " + mSettings.mExternalSdkPlatform + " to "
15350 + mSdkVersion + "; regranting permissions for external storage");
15351 mSettings.mExternalSdkPlatform = mSdkVersion;
15353 // Make sure group IDs have been assigned, and any permission
15354 // changes in other apps are accounted for
15355 updatePermissionsLPw(null, null, UPDATE_PERMISSIONS_ALL
15356 | (regrantPermissions
15357 ? (UPDATE_PERMISSIONS_REPLACE_PKG|UPDATE_PERMISSIONS_REPLACE_ALL)
15360 mSettings.updateExternalDatabaseVersion();
15362 // can downgrade to reader
15363 // Persist settings
15364 mSettings.writeLPr();
15366 // Send a broadcast to let everyone know we are done processing
15367 if (pkgList.size() > 0) {
15368 sendResourcesChangedBroadcast(true, false, pkgList, uidArr, null);
15373 * Utility method to unload a list of specified containers
15375 private void unloadAllContainers(Set<AsecInstallArgs> cidArgs) {
15376 // Just unmount all valid containers.
15377 for (AsecInstallArgs arg : cidArgs) {
15378 synchronized (mInstallLock) {
15379 arg.doPostDeleteLI(false);
15385 * Unload packages mounted on external media. This involves deleting package
15386 * data from internal structures, sending broadcasts about diabled packages,
15387 * gc'ing to free up references, unmounting all secure containers
15388 * corresponding to packages on external media, and posting a
15389 * UPDATED_MEDIA_STATUS message if status has been requested. Please note
15390 * that we always have to post this message if status has been requested no
15393 private void unloadMediaPackages(ArrayMap<AsecInstallArgs, String> processCids, int uidArr[],
15394 final boolean reportStatus) {
15395 if (DEBUG_SD_INSTALL)
15396 Log.i(TAG, "unloading media packages");
15397 ArrayList<String> pkgList = new ArrayList<String>();
15398 ArrayList<AsecInstallArgs> failedList = new ArrayList<AsecInstallArgs>();
15399 final Set<AsecInstallArgs> keys = processCids.keySet();
15400 for (AsecInstallArgs args : keys) {
15401 String pkgName = args.getPackageName();
15402 if (DEBUG_SD_INSTALL)
15403 Log.i(TAG, "Trying to unload pkg : " + pkgName);
15404 // Delete package internally
15405 PackageRemovedInfo outInfo = new PackageRemovedInfo();
15406 synchronized (mInstallLock) {
15407 boolean res = deletePackageLI(pkgName, null, false, null, null,
15408 PackageManager.DELETE_KEEP_DATA, outInfo, false);
15410 pkgList.add(pkgName);
15412 Slog.e(TAG, "Failed to delete pkg from sdcard : " + pkgName);
15413 failedList.add(args);
15419 synchronized (mPackages) {
15420 // We didn't update the settings after removing each package;
15421 // write them now for all packages.
15422 mSettings.writeLPr();
15425 // We have to absolutely send UPDATED_MEDIA_STATUS only
15426 // after confirming that all the receivers processed the ordered
15427 // broadcast when packages get disabled, force a gc to clean things up.
15428 // and unload all the containers.
15429 if (pkgList.size() > 0) {
15430 sendResourcesChangedBroadcast(false, false, pkgList, uidArr,
15431 new IIntentReceiver.Stub() {
15432 public void performReceive(Intent intent, int resultCode, String data,
15433 Bundle extras, boolean ordered, boolean sticky,
15434 int sendingUser) throws RemoteException {
15435 Message msg = mHandler.obtainMessage(UPDATED_MEDIA_STATUS,
15436 reportStatus ? 1 : 0, 1, keys);
15437 mHandler.sendMessage(msg);
15441 Message msg = mHandler.obtainMessage(UPDATED_MEDIA_STATUS, reportStatus ? 1 : 0, -1,
15443 mHandler.sendMessage(msg);
15447 private void loadPrivatePackages(VolumeInfo vol) {
15448 final ArrayList<ApplicationInfo> loaded = new ArrayList<>();
15449 final int parseFlags = mDefParseFlags | PackageParser.PARSE_EXTERNAL_STORAGE;
15450 synchronized (mInstallLock) {
15451 synchronized (mPackages) {
15452 final List<PackageSetting> packages = mSettings.getVolumePackagesLPr(vol.fsUuid);
15453 for (PackageSetting ps : packages) {
15454 final PackageParser.Package pkg;
15456 pkg = scanPackageLI(ps.codePath, parseFlags, SCAN_INITIAL, 0L, null);
15457 loaded.add(pkg.applicationInfo);
15458 } catch (PackageManagerException e) {
15459 Slog.w(TAG, "Failed to scan " + ps.codePath + ": " + e.getMessage());
15463 // TODO: regrant any permissions that changed based since original install
15465 mSettings.writeLPr();
15469 if (DEBUG_INSTALL) Slog.d(TAG, "Loaded packages " + loaded);
15470 sendResourcesChangedBroadcast(true, false, loaded, null);
15473 private void unloadPrivatePackages(VolumeInfo vol) {
15474 final ArrayList<ApplicationInfo> unloaded = new ArrayList<>();
15475 synchronized (mInstallLock) {
15476 synchronized (mPackages) {
15477 final List<PackageSetting> packages = mSettings.getVolumePackagesLPr(vol.fsUuid);
15478 for (PackageSetting ps : packages) {
15479 if (ps.pkg == null) continue;
15481 final ApplicationInfo info = ps.pkg.applicationInfo;
15482 final PackageRemovedInfo outInfo = new PackageRemovedInfo();
15483 if (deletePackageLI(ps.name, null, false, null, null,
15484 PackageManager.DELETE_KEEP_DATA, outInfo, false)) {
15485 unloaded.add(info);
15487 Slog.w(TAG, "Failed to unload " + ps.codePath);
15491 mSettings.writeLPr();
15495 if (DEBUG_INSTALL) Slog.d(TAG, "Unloaded packages " + unloaded);
15496 sendResourcesChangedBroadcast(false, false, unloaded, null);
15500 * Examine all users present on given mounted volume, and destroy data
15501 * belonging to users that are no longer valid, or whose user ID has been
15504 private void reconcileUsers(String volumeUuid) {
15505 final File[] files = Environment.getDataUserDirectory(volumeUuid).listFiles();
15506 if (ArrayUtils.isEmpty(files)) {
15507 Slog.d(TAG, "No users found on " + volumeUuid);
15511 for (File file : files) {
15512 if (!file.isDirectory()) continue;
15515 final UserInfo info;
15517 userId = Integer.parseInt(file.getName());
15518 info = sUserManager.getUserInfo(userId);
15519 } catch (NumberFormatException e) {
15520 Slog.w(TAG, "Invalid user directory " + file);
15524 boolean destroyUser = false;
15525 if (info == null) {
15526 logCriticalInfo(Log.WARN, "Destroying user directory " + file
15527 + " because no matching user was found");
15528 destroyUser = true;
15531 UserManagerService.enforceSerialNumber(file, info.serialNumber);
15532 } catch (IOException e) {
15533 logCriticalInfo(Log.WARN, "Destroying user directory " + file
15534 + " because we failed to enforce serial number: " + e);
15535 destroyUser = true;
15540 synchronized (mInstallLock) {
15541 mInstaller.removeUserDataDirs(volumeUuid, userId);
15546 final UserManager um = mContext.getSystemService(UserManager.class);
15547 for (UserInfo user : um.getUsers()) {
15548 final File userDir = Environment.getDataUserDirectory(volumeUuid, user.id);
15549 if (userDir.exists()) continue;
15552 UserManagerService.prepareUserDirectory(mContext, volumeUuid, user.id);
15553 UserManagerService.enforceSerialNumber(userDir, user.serialNumber);
15554 } catch (IOException e) {
15555 Log.wtf(TAG, "Failed to create user directory on " + volumeUuid, e);
15561 * Examine all apps present on given mounted volume, and destroy apps that
15562 * aren't expected, either due to uninstallation or reinstallation on
15565 private void reconcileApps(String volumeUuid) {
15566 final File[] files = Environment.getDataAppDirectory(volumeUuid).listFiles();
15567 if (ArrayUtils.isEmpty(files)) {
15568 Slog.d(TAG, "No apps found on " + volumeUuid);
15572 for (File file : files) {
15573 final boolean isPackage = (isApkFile(file) || file.isDirectory())
15574 && !PackageInstallerService.isStageName(file.getName());
15576 // Ignore entries which are not packages
15580 boolean destroyApp = false;
15581 String packageName = null;
15583 final PackageLite pkg = PackageParser.parsePackageLite(file,
15584 PackageParser.PARSE_MUST_BE_APK);
15585 packageName = pkg.packageName;
15587 synchronized (mPackages) {
15588 final PackageSetting ps = mSettings.mPackages.get(packageName);
15590 logCriticalInfo(Log.WARN, "Destroying " + packageName + " on + "
15591 + volumeUuid + " because we found no install record");
15593 } else if (!TextUtils.equals(volumeUuid, ps.volumeUuid)) {
15594 logCriticalInfo(Log.WARN, "Destroying " + packageName + " on "
15595 + volumeUuid + " because we expected it on " + ps.volumeUuid);
15600 } catch (PackageParserException e) {
15601 logCriticalInfo(Log.WARN, "Destroying " + file + " due to parse failure: " + e);
15606 synchronized (mInstallLock) {
15607 if (packageName != null) {
15608 removeDataDirsLI(volumeUuid, packageName);
15610 if (file.isDirectory()) {
15611 mInstaller.rmPackageDir(file.getAbsolutePath());
15620 private void unfreezePackage(String packageName) {
15621 synchronized (mPackages) {
15622 final PackageSetting ps = mSettings.mPackages.get(packageName);
15630 public int movePackage(final String packageName, final String volumeUuid) {
15631 mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MOVE_PACKAGE, null);
15633 final int moveId = mNextMoveId.getAndIncrement();
15635 movePackageInternal(packageName, volumeUuid, moveId);
15636 } catch (PackageManagerException e) {
15637 Slog.w(TAG, "Failed to move " + packageName, e);
15638 mMoveCallbacks.notifyStatusChanged(moveId,
15639 PackageManager.MOVE_FAILED_INTERNAL_ERROR);
15644 private void movePackageInternal(final String packageName, final String volumeUuid,
15645 final int moveId) throws PackageManagerException {
15646 final UserHandle user = new UserHandle(UserHandle.getCallingUserId());
15647 final StorageManager storage = mContext.getSystemService(StorageManager.class);
15648 final PackageManager pm = mContext.getPackageManager();
15650 final boolean currentAsec;
15651 final String currentVolumeUuid;
15652 final File codeFile;
15653 final String installerPackageName;
15654 final String packageAbiOverride;
15656 final String seinfo;
15657 final String label;
15660 synchronized (mPackages) {
15661 final PackageParser.Package pkg = mPackages.get(packageName);
15662 final PackageSetting ps = mSettings.mPackages.get(packageName);
15663 if (pkg == null || ps == null) {
15664 throw new PackageManagerException(MOVE_FAILED_DOESNT_EXIST, "Missing package");
15667 if (pkg.applicationInfo.isSystemApp()) {
15668 throw new PackageManagerException(MOVE_FAILED_SYSTEM_PACKAGE,
15669 "Cannot move system application");
15672 if (Objects.equals(ps.volumeUuid, volumeUuid)) {
15673 throw new PackageManagerException(MOVE_FAILED_INTERNAL_ERROR,
15674 "Package already moved to " + volumeUuid);
15677 final File probe = new File(pkg.codePath);
15678 final File probeOat = new File(probe, "oat");
15679 if (!probe.isDirectory() || !probeOat.isDirectory()) {
15680 throw new PackageManagerException(MOVE_FAILED_INTERNAL_ERROR,
15681 "Move only supported for modern cluster style installs");
15685 throw new PackageManagerException(MOVE_FAILED_OPERATION_PENDING,
15686 "Failed to move already frozen package");
15690 currentAsec = pkg.applicationInfo.isForwardLocked()
15691 || pkg.applicationInfo.isExternalAsec();
15692 currentVolumeUuid = ps.volumeUuid;
15693 codeFile = new File(pkg.codePath);
15694 installerPackageName = ps.installerPackageName;
15695 packageAbiOverride = ps.cpuAbiOverrideString;
15696 appId = UserHandle.getAppId(pkg.applicationInfo.uid);
15697 seinfo = pkg.applicationInfo.seinfo;
15698 label = String.valueOf(pm.getApplicationLabel(pkg.applicationInfo));
15701 // Now that we're guarded by frozen state, kill app during move
15702 killApplication(packageName, appId, "move pkg");
15704 final Bundle extras = new Bundle();
15705 extras.putString(Intent.EXTRA_PACKAGE_NAME, packageName);
15706 extras.putString(Intent.EXTRA_TITLE, label);
15707 mMoveCallbacks.notifyCreated(moveId, extras);
15710 final boolean moveCompleteApp;
15711 final File measurePath;
15713 if (Objects.equals(StorageManager.UUID_PRIVATE_INTERNAL, volumeUuid)) {
15714 installFlags = INSTALL_INTERNAL;
15715 moveCompleteApp = !currentAsec;
15716 measurePath = Environment.getDataAppDirectory(volumeUuid);
15717 } else if (Objects.equals(StorageManager.UUID_PRIMARY_PHYSICAL, volumeUuid)) {
15718 installFlags = INSTALL_EXTERNAL;
15719 moveCompleteApp = false;
15720 measurePath = storage.getPrimaryPhysicalVolume().getPath();
15722 final VolumeInfo volume = storage.findVolumeByUuid(volumeUuid);
15723 if (volume == null || volume.getType() != VolumeInfo.TYPE_PRIVATE
15724 || !volume.isMountedWritable()) {
15725 unfreezePackage(packageName);
15726 throw new PackageManagerException(MOVE_FAILED_INTERNAL_ERROR,
15727 "Move location not mounted private volume");
15730 Preconditions.checkState(!currentAsec);
15732 installFlags = INSTALL_INTERNAL;
15733 moveCompleteApp = true;
15734 measurePath = Environment.getDataAppDirectory(volumeUuid);
15737 final PackageStats stats = new PackageStats(null, -1);
15738 synchronized (mInstaller) {
15739 if (!getPackageSizeInfoLI(packageName, -1, stats)) {
15740 unfreezePackage(packageName);
15741 throw new PackageManagerException(MOVE_FAILED_INTERNAL_ERROR,
15742 "Failed to measure package size");
15746 if (DEBUG_INSTALL) Slog.d(TAG, "Measured code size " + stats.codeSize + ", data size "
15749 final long startFreeBytes = measurePath.getFreeSpace();
15750 final long sizeBytes;
15751 if (moveCompleteApp) {
15752 sizeBytes = stats.codeSize + stats.dataSize;
15754 sizeBytes = stats.codeSize;
15757 if (sizeBytes > storage.getStorageBytesUntilLow(measurePath)) {
15758 unfreezePackage(packageName);
15759 throw new PackageManagerException(MOVE_FAILED_INTERNAL_ERROR,
15760 "Not enough free space to move");
15763 mMoveCallbacks.notifyStatusChanged(moveId, 10);
15765 final CountDownLatch installedLatch = new CountDownLatch(1);
15766 final IPackageInstallObserver2 installObserver = new IPackageInstallObserver2.Stub() {
15768 public void onUserActionRequired(Intent intent) throws RemoteException {
15769 throw new IllegalStateException();
15773 public void onPackageInstalled(String basePackageName, int returnCode, String msg,
15774 Bundle extras) throws RemoteException {
15775 if (DEBUG_INSTALL) Slog.d(TAG, "Install result for move: "
15776 + PackageManager.installStatusToString(returnCode, msg));
15778 installedLatch.countDown();
15780 // Regardless of success or failure of the move operation,
15781 // always unfreeze the package
15782 unfreezePackage(packageName);
15784 final int status = PackageManager.installStatusToPublicStatus(returnCode);
15786 case PackageInstaller.STATUS_SUCCESS:
15787 mMoveCallbacks.notifyStatusChanged(moveId,
15788 PackageManager.MOVE_SUCCEEDED);
15790 case PackageInstaller.STATUS_FAILURE_STORAGE:
15791 mMoveCallbacks.notifyStatusChanged(moveId,
15792 PackageManager.MOVE_FAILED_INSUFFICIENT_STORAGE);
15795 mMoveCallbacks.notifyStatusChanged(moveId,
15796 PackageManager.MOVE_FAILED_INTERNAL_ERROR);
15802 final MoveInfo move;
15803 if (moveCompleteApp) {
15804 // Kick off a thread to report progress estimates
15807 public void run() {
15810 if (installedLatch.await(1, TimeUnit.SECONDS)) {
15813 } catch (InterruptedException ignored) {
15816 final long deltaFreeBytes = startFreeBytes - measurePath.getFreeSpace();
15817 final int progress = 10 + (int) MathUtils.constrain(
15818 ((deltaFreeBytes * 80) / sizeBytes), 0, 80);
15819 mMoveCallbacks.notifyStatusChanged(moveId, progress);
15824 final String dataAppName = codeFile.getName();
15825 move = new MoveInfo(moveId, currentVolumeUuid, volumeUuid, packageName,
15826 dataAppName, appId, seinfo);
15831 installFlags |= PackageManager.INSTALL_REPLACE_EXISTING;
15833 final Message msg = mHandler.obtainMessage(INIT_COPY);
15834 final OriginInfo origin = OriginInfo.fromExistingFile(codeFile);
15835 msg.obj = new InstallParams(origin, move, installObserver, installFlags,
15836 installerPackageName, volumeUuid, null, user, packageAbiOverride);
15837 mHandler.sendMessage(msg);
15841 public int movePrimaryStorage(String volumeUuid) throws RemoteException {
15842 mContext.enforceCallingOrSelfPermission(android.Manifest.permission.MOVE_PACKAGE, null);
15844 final int realMoveId = mNextMoveId.getAndIncrement();
15845 final Bundle extras = new Bundle();
15846 extras.putString(VolumeRecord.EXTRA_FS_UUID, volumeUuid);
15847 mMoveCallbacks.notifyCreated(realMoveId, extras);
15849 final IPackageMoveObserver callback = new IPackageMoveObserver.Stub() {
15851 public void onCreated(int moveId, Bundle extras) {
15856 public void onStatusChanged(int moveId, int status, long estMillis) {
15857 mMoveCallbacks.notifyStatusChanged(realMoveId, status, estMillis);
15861 final StorageManager storage = mContext.getSystemService(StorageManager.class);
15862 storage.setPrimaryStorageUuid(volumeUuid, callback);
15867 public int getMoveStatus(int moveId) {
15868 mContext.enforceCallingOrSelfPermission(
15869 android.Manifest.permission.MOUNT_UNMOUNT_FILESYSTEMS, null);
15870 return mMoveCallbacks.mLastStatus.get(moveId);
15874 public void registerMoveCallback(IPackageMoveObserver callback) {
15875 mContext.enforceCallingOrSelfPermission(
15876 android.Manifest.permission.MOUNT_UNMOUNT_FILESYSTEMS, null);
15877 mMoveCallbacks.register(callback);
15881 public void unregisterMoveCallback(IPackageMoveObserver callback) {
15882 mContext.enforceCallingOrSelfPermission(
15883 android.Manifest.permission.MOUNT_UNMOUNT_FILESYSTEMS, null);
15884 mMoveCallbacks.unregister(callback);
15888 public boolean setInstallLocation(int loc) {
15889 mContext.enforceCallingOrSelfPermission(android.Manifest.permission.WRITE_SECURE_SETTINGS,
15891 if (getInstallLocation() == loc) {
15894 if (loc == PackageHelper.APP_INSTALL_AUTO || loc == PackageHelper.APP_INSTALL_INTERNAL
15895 || loc == PackageHelper.APP_INSTALL_EXTERNAL) {
15896 android.provider.Settings.Global.putInt(mContext.getContentResolver(),
15897 android.provider.Settings.Global.DEFAULT_INSTALL_LOCATION, loc);
15904 public int getInstallLocation() {
15905 return android.provider.Settings.Global.getInt(mContext.getContentResolver(),
15906 android.provider.Settings.Global.DEFAULT_INSTALL_LOCATION,
15907 PackageHelper.APP_INSTALL_AUTO);
15910 /** Called by UserManagerService */
15911 void cleanUpUserLILPw(UserManagerService userManager, int userHandle) {
15912 mDirtyUsers.remove(userHandle);
15913 mSettings.removeUserLPw(userHandle);
15914 mPendingBroadcasts.remove(userHandle);
15915 if (mInstaller != null) {
15916 // Technically, we shouldn't be doing this with the package lock
15917 // held. However, this is very rare, and there is already so much
15918 // other disk I/O going on, that we'll let it slide for now.
15919 final StorageManager storage = mContext.getSystemService(StorageManager.class);
15920 for (VolumeInfo vol : storage.getWritablePrivateVolumes()) {
15921 final String volumeUuid = vol.getFsUuid();
15922 if (DEBUG_INSTALL) Slog.d(TAG, "Removing user data on volume " + volumeUuid);
15923 mInstaller.removeUserDataDirs(volumeUuid, userHandle);
15926 mUserNeedsBadging.delete(userHandle);
15927 removeUnusedPackagesLILPw(userManager, userHandle);
15931 * We're removing userHandle and would like to remove any downloaded packages
15932 * that are no longer in use by any other user.
15933 * @param userHandle the user being removed
15935 private void removeUnusedPackagesLILPw(UserManagerService userManager, final int userHandle) {
15936 final boolean DEBUG_CLEAN_APKS = false;
15937 int [] users = userManager.getUserIdsLPr();
15938 Iterator<PackageSetting> psit = mSettings.mPackages.values().iterator();
15939 while (psit.hasNext()) {
15940 PackageSetting ps = psit.next();
15941 if (ps.pkg == null) {
15944 final String packageName = ps.pkg.packageName;
15945 // Skip over if system app
15946 if ((ps.pkgFlags & ApplicationInfo.FLAG_SYSTEM) != 0) {
15949 if (DEBUG_CLEAN_APKS) {
15950 Slog.i(TAG, "Checking package " + packageName);
15952 boolean keep = false;
15953 for (int i = 0; i < users.length; i++) {
15954 if (users[i] != userHandle && ps.getInstalled(users[i])) {
15956 if (DEBUG_CLEAN_APKS) {
15957 Slog.i(TAG, " Keeping package " + packageName + " for user "
15964 if (DEBUG_CLEAN_APKS) {
15965 Slog.i(TAG, " Removing package " + packageName);
15967 mHandler.post(new Runnable() {
15968 public void run() {
15969 deletePackageX(packageName, userHandle, 0);
15976 /** Called by UserManagerService */
15977 void createNewUserLILPw(int userHandle) {
15978 if (mInstaller != null) {
15979 mInstaller.createUserConfig(userHandle);
15980 mSettings.createNewUserLILPw(this, mInstaller, userHandle);
15981 applyFactoryDefaultBrowserLPw(userHandle);
15982 primeDomainVerificationsLPw(userHandle);
15986 void newUserCreated(final int userHandle) {
15987 mDefaultPermissionPolicy.grantDefaultPermissions(userHandle);
15991 public VerifierDeviceIdentity getVerifierDeviceIdentity() throws RemoteException {
15992 mContext.enforceCallingOrSelfPermission(
15993 android.Manifest.permission.PACKAGE_VERIFICATION_AGENT,
15994 "Only package verification agents can read the verifier device identity");
15996 synchronized (mPackages) {
15997 return mSettings.getVerifierDeviceIdentityLPw();
16002 public void setPermissionEnforced(String permission, boolean enforced) {
16003 mContext.enforceCallingOrSelfPermission(GRANT_REVOKE_PERMISSIONS, null);
16004 if (READ_EXTERNAL_STORAGE.equals(permission)) {
16005 synchronized (mPackages) {
16006 if (mSettings.mReadExternalStorageEnforced == null
16007 || mSettings.mReadExternalStorageEnforced != enforced) {
16008 mSettings.mReadExternalStorageEnforced = enforced;
16009 mSettings.writeLPr();
16012 // kill any non-foreground processes so we restart them and
16013 // grant/revoke the GID.
16014 final IActivityManager am = ActivityManagerNative.getDefault();
16016 final long token = Binder.clearCallingIdentity();
16018 am.killProcessesBelowForeground("setPermissionEnforcement");
16019 } catch (RemoteException e) {
16021 Binder.restoreCallingIdentity(token);
16025 throw new IllegalArgumentException("No selective enforcement for " + permission);
16031 public boolean isPermissionEnforced(String permission) {
16036 public boolean isStorageLow() {
16037 final long token = Binder.clearCallingIdentity();
16039 final DeviceStorageMonitorInternal
16040 dsm = LocalServices.getService(DeviceStorageMonitorInternal.class);
16042 return dsm.isMemoryLow();
16047 Binder.restoreCallingIdentity(token);
16052 public IPackageInstaller getPackageInstaller() {
16053 return mInstallerService;
16056 private boolean userNeedsBadging(int userId) {
16057 int index = mUserNeedsBadging.indexOfKey(userId);
16059 final UserInfo userInfo;
16060 final long token = Binder.clearCallingIdentity();
16062 userInfo = sUserManager.getUserInfo(userId);
16064 Binder.restoreCallingIdentity(token);
16067 if (userInfo != null && userInfo.isManagedProfile()) {
16072 mUserNeedsBadging.put(userId, b);
16075 return mUserNeedsBadging.valueAt(index);
16079 public KeySet getKeySetByAlias(String packageName, String alias) {
16080 if (packageName == null || alias == null) {
16083 synchronized(mPackages) {
16084 final PackageParser.Package pkg = mPackages.get(packageName);
16086 Slog.w(TAG, "KeySet requested for unknown package:" + packageName);
16087 throw new IllegalArgumentException("Unknown package: " + packageName);
16089 KeySetManagerService ksms = mSettings.mKeySetManagerService;
16090 return new KeySet(ksms.getKeySetByAliasAndPackageNameLPr(packageName, alias));
16095 public KeySet getSigningKeySet(String packageName) {
16096 if (packageName == null) {
16099 synchronized(mPackages) {
16100 final PackageParser.Package pkg = mPackages.get(packageName);
16102 Slog.w(TAG, "KeySet requested for unknown package:" + packageName);
16103 throw new IllegalArgumentException("Unknown package: " + packageName);
16105 if (pkg.applicationInfo.uid != Binder.getCallingUid()
16106 && Process.SYSTEM_UID != Binder.getCallingUid()) {
16107 throw new SecurityException("May not access signing KeySet of other apps.");
16109 KeySetManagerService ksms = mSettings.mKeySetManagerService;
16110 return new KeySet(ksms.getSigningKeySetByPackageNameLPr(packageName));
16115 public boolean isPackageSignedByKeySet(String packageName, KeySet ks) {
16116 if (packageName == null || ks == null) {
16119 synchronized(mPackages) {
16120 final PackageParser.Package pkg = mPackages.get(packageName);
16122 Slog.w(TAG, "KeySet requested for unknown package:" + packageName);
16123 throw new IllegalArgumentException("Unknown package: " + packageName);
16125 IBinder ksh = ks.getToken();
16126 if (ksh instanceof KeySetHandle) {
16127 KeySetManagerService ksms = mSettings.mKeySetManagerService;
16128 return ksms.packageIsSignedByLPr(packageName, (KeySetHandle) ksh);
16135 public boolean isPackageSignedByKeySetExactly(String packageName, KeySet ks) {
16136 if (packageName == null || ks == null) {
16139 synchronized(mPackages) {
16140 final PackageParser.Package pkg = mPackages.get(packageName);
16142 Slog.w(TAG, "KeySet requested for unknown package:" + packageName);
16143 throw new IllegalArgumentException("Unknown package: " + packageName);
16145 IBinder ksh = ks.getToken();
16146 if (ksh instanceof KeySetHandle) {
16147 KeySetManagerService ksms = mSettings.mKeySetManagerService;
16148 return ksms.packageIsSignedByExactlyLPr(packageName, (KeySetHandle) ksh);
16154 public void getUsageStatsIfNoPackageUsageInfo() {
16155 if (!mPackageUsage.isHistoricalPackageUsageAvailable()) {
16156 UsageStatsManager usm = (UsageStatsManager) mContext.getSystemService(Context.USAGE_STATS_SERVICE);
16158 throw new IllegalStateException("UsageStatsManager must be initialized");
16160 long now = System.currentTimeMillis();
16161 Map<String, UsageStats> stats = usm.queryAndAggregateUsageStats(now - mDexOptLRUThresholdInMills, now);
16162 for (Map.Entry<String, UsageStats> entry : stats.entrySet()) {
16163 String packageName = entry.getKey();
16164 PackageParser.Package pkg = mPackages.get(packageName);
16168 UsageStats usage = entry.getValue();
16169 pkg.mLastPackageUsageTimeInMills = usage.getLastTimeUsed();
16170 mPackageUsage.mIsHistoricalPackageUsageAvailable = true;
16176 * Check and throw if the given before/after packages would be considered a
16179 private static void checkDowngrade(PackageParser.Package before, PackageInfoLite after)
16180 throws PackageManagerException {
16181 if (after.versionCode < before.mVersionCode) {
16182 throw new PackageManagerException(INSTALL_FAILED_VERSION_DOWNGRADE,
16183 "Update version code " + after.versionCode + " is older than current "
16184 + before.mVersionCode);
16185 } else if (after.versionCode == before.mVersionCode) {
16186 if (after.baseRevisionCode < before.baseRevisionCode) {
16187 throw new PackageManagerException(INSTALL_FAILED_VERSION_DOWNGRADE,
16188 "Update base revision code " + after.baseRevisionCode
16189 + " is older than current " + before.baseRevisionCode);
16192 if (!ArrayUtils.isEmpty(after.splitNames)) {
16193 for (int i = 0; i < after.splitNames.length; i++) {
16194 final String splitName = after.splitNames[i];
16195 final int j = ArrayUtils.indexOf(before.splitNames, splitName);
16197 if (after.splitRevisionCodes[i] < before.splitRevisionCodes[j]) {
16198 throw new PackageManagerException(INSTALL_FAILED_VERSION_DOWNGRADE,
16199 "Update split " + splitName + " revision code "
16200 + after.splitRevisionCodes[i] + " is older than current "
16201 + before.splitRevisionCodes[j]);
16209 private static class MoveCallbacks extends Handler {
16210 private static final int MSG_CREATED = 1;
16211 private static final int MSG_STATUS_CHANGED = 2;
16213 private final RemoteCallbackList<IPackageMoveObserver>
16214 mCallbacks = new RemoteCallbackList<>();
16216 private final SparseIntArray mLastStatus = new SparseIntArray();
16218 public MoveCallbacks(Looper looper) {
16222 public void register(IPackageMoveObserver callback) {
16223 mCallbacks.register(callback);
16226 public void unregister(IPackageMoveObserver callback) {
16227 mCallbacks.unregister(callback);
16231 public void handleMessage(Message msg) {
16232 final SomeArgs args = (SomeArgs) msg.obj;
16233 final int n = mCallbacks.beginBroadcast();
16234 for (int i = 0; i < n; i++) {
16235 final IPackageMoveObserver callback = mCallbacks.getBroadcastItem(i);
16237 invokeCallback(callback, msg.what, args);
16238 } catch (RemoteException ignored) {
16241 mCallbacks.finishBroadcast();
16245 private void invokeCallback(IPackageMoveObserver callback, int what, SomeArgs args)
16246 throws RemoteException {
16248 case MSG_CREATED: {
16249 callback.onCreated(args.argi1, (Bundle) args.arg2);
16252 case MSG_STATUS_CHANGED: {
16253 callback.onStatusChanged(args.argi1, args.argi2, (long) args.arg3);
16259 private void notifyCreated(int moveId, Bundle extras) {
16260 Slog.v(TAG, "Move " + moveId + " created " + extras.toString());
16262 final SomeArgs args = SomeArgs.obtain();
16263 args.argi1 = moveId;
16264 args.arg2 = extras;
16265 obtainMessage(MSG_CREATED, args).sendToTarget();
16268 private void notifyStatusChanged(int moveId, int status) {
16269 notifyStatusChanged(moveId, status, -1);
16272 private void notifyStatusChanged(int moveId, int status, long estMillis) {
16273 Slog.v(TAG, "Move " + moveId + " status " + status);
16275 final SomeArgs args = SomeArgs.obtain();
16276 args.argi1 = moveId;
16277 args.argi2 = status;
16278 args.arg3 = estMillis;
16279 obtainMessage(MSG_STATUS_CHANGED, args).sendToTarget();
16281 synchronized (mLastStatus) {
16282 mLastStatus.put(moveId, status);
16287 private final class OnPermissionChangeListeners extends Handler {
16288 private static final int MSG_ON_PERMISSIONS_CHANGED = 1;
16290 private final RemoteCallbackList<IOnPermissionsChangeListener> mPermissionListeners =
16291 new RemoteCallbackList<>();
16293 public OnPermissionChangeListeners(Looper looper) {
16298 public void handleMessage(Message msg) {
16299 switch (msg.what) {
16300 case MSG_ON_PERMISSIONS_CHANGED: {
16301 final int uid = msg.arg1;
16302 handleOnPermissionsChanged(uid);
16307 public void addListenerLocked(IOnPermissionsChangeListener listener) {
16308 mPermissionListeners.register(listener);
16312 public void removeListenerLocked(IOnPermissionsChangeListener listener) {
16313 mPermissionListeners.unregister(listener);
16316 public void onPermissionsChanged(int uid) {
16317 if (mPermissionListeners.getRegisteredCallbackCount() > 0) {
16318 obtainMessage(MSG_ON_PERMISSIONS_CHANGED, uid, 0).sendToTarget();
16322 private void handleOnPermissionsChanged(int uid) {
16323 final int count = mPermissionListeners.beginBroadcast();
16325 for (int i = 0; i < count; i++) {
16326 IOnPermissionsChangeListener callback = mPermissionListeners
16327 .getBroadcastItem(i);
16329 callback.onPermissionsChanged(uid);
16330 } catch (RemoteException e) {
16331 Log.e(TAG, "Permission listener is dead", e);
16335 mPermissionListeners.finishBroadcast();
16340 private class PackageManagerInternalImpl extends PackageManagerInternal {
16342 public void setLocationPackagesProvider(PackagesProvider provider) {
16343 synchronized (mPackages) {
16344 mDefaultPermissionPolicy.setLocationPackagesProviderLPw(provider);
16349 public void setImePackagesProvider(PackagesProvider provider) {
16350 synchronized (mPackages) {
16351 mDefaultPermissionPolicy.setImePackagesProviderLPr(provider);
16356 public void setVoiceInteractionPackagesProvider(PackagesProvider provider) {
16357 synchronized (mPackages) {
16358 mDefaultPermissionPolicy.setVoiceInteractionPackagesProviderLPw(provider);
16363 public void setSmsAppPackagesProvider(PackagesProvider provider) {
16364 synchronized (mPackages) {
16365 mDefaultPermissionPolicy.setSmsAppPackagesProviderLPw(provider);
16370 public void setDialerAppPackagesProvider(PackagesProvider provider) {
16371 synchronized (mPackages) {
16372 mDefaultPermissionPolicy.setDialerAppPackagesProviderLPw(provider);
16377 public void setSyncAdapterPackagesprovider(SyncAdapterPackagesProvider provider) {
16378 synchronized (mPackages) {
16379 mDefaultPermissionPolicy.setSyncAdapterPackagesProviderrLPw(provider);
16384 public void grantDefaultPermissionsToDefaultSmsApp(String packageName, int userId) {
16385 synchronized (mPackages) {
16386 mDefaultPermissionPolicy.grantDefaultPermissionsToDefaultSmsAppLPr(
16387 packageName, userId);
16392 public void grantDefaultPermissionsToDefaultDialerApp(String packageName, int userId) {
16393 synchronized (mPackages) {
16394 mDefaultPermissionPolicy.grantDefaultPermissionsToDefaultDialerAppLPr(
16395 packageName, userId);
16401 public void grantDefaultPermissionsToEnabledCarrierApps(String[] packageNames, int userId) {
16402 enforceSystemOrPhoneCaller("grantPermissionsToEnabledCarrierApps");
16403 synchronized (mPackages) {
16404 final long identity = Binder.clearCallingIdentity();
16406 mDefaultPermissionPolicy.grantDefaultPermissionsToEnabledCarrierAppsLPr(
16407 packageNames, userId);
16409 Binder.restoreCallingIdentity(identity);
16414 private static void enforceSystemOrPhoneCaller(String tag) {
16415 int callingUid = Binder.getCallingUid();
16416 if (callingUid != Process.PHONE_UID && callingUid != Process.SYSTEM_UID) {
16417 throw new SecurityException(
16418 "Cannot call " + tag + " from UID " + callingUid);