services/core/java/com/android/server/pm/ShortcutService.java

   1 /*
   2  * Copyright (C) 2016 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package com.android.server.pm;
  17
  18 import android.annotation.IntDef;
  19 import android.annotation.NonNull;
  20 import android.annotation.Nullable;
  21 import android.annotation.UserIdInt;
  22 import android.app.ActivityManager;
  23 import android.app.ActivityManagerInternal;
  24 import android.app.ActivityManagerNative;
  25 import android.app.AppGlobals;
  26 import android.app.IUidObserver;
  27 import android.app.usage.UsageStatsManagerInternal;
  28 import android.content.BroadcastReceiver;
  29 import android.content.ComponentName;
  30 import android.content.Context;
  31 import android.content.Intent;
  32 import android.content.IntentFilter;
  33 import android.content.pm.ActivityInfo;
  34 import android.content.pm.ApplicationInfo;
  35 import android.content.pm.IPackageManager;
  36 import android.content.pm.IShortcutService;
  37 import android.content.pm.LauncherApps;
  38 import android.content.pm.LauncherApps.ShortcutQuery;
  39 import android.content.pm.PackageInfo;
  40 import android.content.pm.PackageManager;
  41 import android.content.pm.PackageManager.NameNotFoundException;
  42 import android.content.pm.PackageManagerInternal;
  43 import android.content.pm.ParceledListSlice;
  44 import android.content.pm.ResolveInfo;
  45 import android.content.pm.ShortcutInfo;
  46 import android.content.pm.ShortcutServiceInternal;
  47 import android.content.pm.ShortcutServiceInternal.ShortcutChangeListener;
  48 import android.content.res.Resources;
  49 import android.content.res.XmlResourceParser;
  50 import android.graphics.Bitmap;
  51 import android.graphics.Bitmap.CompressFormat;
  52 import android.graphics.Canvas;
  53 import android.graphics.RectF;
  54 import android.graphics.drawable.Icon;
  55 import android.net.Uri;
  56 import android.os.Binder;
  57 import android.os.Build;
  58 import android.os.Environment;
  59 import android.os.FileUtils;
  60 import android.os.Handler;
  61 import android.os.LocaleList;
  62 import android.os.Looper;
  63 import android.os.ParcelFileDescriptor;
  64 import android.os.PersistableBundle;
  65 import android.os.Process;
  66 import android.os.RemoteException;
  67 import android.os.ResultReceiver;
  68 import android.os.SELinux;
  69 import android.os.ServiceManager;
  70 import android.os.ShellCommand;
  71 import android.os.SystemClock;
  72 import android.os.UserHandle;
  73 import android.os.UserManager;
  74 import android.text.TextUtils;
  75 import android.text.format.Time;
  76 import android.util.ArraySet;
  77 import android.util.AtomicFile;
  78 import android.util.KeyValueListParser;
  79 import android.util.Log;
  80 import android.util.Slog;
  81 import android.util.SparseArray;
  82 import android.util.SparseBooleanArray;
  83 import android.util.SparseIntArray;
  84 import android.util.SparseLongArray;
  85 import android.util.TypedValue;
  86 import android.util.Xml;
  87 import android.view.IWindowManager;
  88
  89 import com.android.internal.annotations.GuardedBy;
  90 import com.android.internal.annotations.VisibleForTesting;
  91 import com.android.internal.os.BackgroundThread;
  92 import com.android.internal.util.FastXmlSerializer;
  93 import com.android.internal.util.Preconditions;
  94 import com.android.server.LocalServices;
  95 import com.android.server.SystemService;
  96 import com.android.server.pm.ShortcutUser.PackageWithUser;
  97
  98 import libcore.io.IoUtils;
  99
 100 import org.json.JSONArray;
 101 import org.json.JSONException;
 102 import org.json.JSONObject;
 103 import org.xmlpull.v1.XmlPullParser;
 104 import org.xmlpull.v1.XmlPullParserException;
 105 import org.xmlpull.v1.XmlSerializer;
 106
 107 import java.io.BufferedInputStream;
 108 import java.io.BufferedOutputStream;
 109 import java.io.ByteArrayInputStream;
 110 import java.io.ByteArrayOutputStream;
 111 import java.io.File;
 112 import java.io.FileDescriptor;
 113 import java.io.FileInputStream;
 114 import java.io.FileNotFoundException;
 115 import java.io.FileOutputStream;
 116 import java.io.IOException;
 117 import java.io.InputStream;
 118 import java.io.OutputStream;
 119 import java.io.PrintWriter;
 120 import java.lang.annotation.Retention;
 121 import java.lang.annotation.RetentionPolicy;
 122 import java.net.URISyntaxException;
 123 import java.nio.charset.StandardCharsets;
 124 import java.util.ArrayList;
 125 import java.util.Collections;
 126 import java.util.List;
 127 import java.util.concurrent.atomic.AtomicBoolean;
 128 import java.util.function.Consumer;
 129 import java.util.function.Predicate;
 130
 131 /**
 132  * TODO:
 133  * - getIconMaxWidth()/getIconMaxHeight() should use xdpi and ydpi.
 134  *   -> But TypedValue.applyDimension() doesn't differentiate x and y..?
 135  *
 136  * - Detect when already registered instances are passed to APIs again, which might break
 137  * internal bitmap handling.
 138  */
 139 public class ShortcutService extends IShortcutService.Stub {
 140     static final String TAG = "ShortcutService";
 141
 142     static final boolean DEBUG = false; // STOPSHIP if true
 143     static final boolean DEBUG_LOAD = false; // STOPSHIP if true
 144     static final boolean DEBUG_PROCSTATE = false; // STOPSHIP if true
 145
 146     @VisibleForTesting
 147     static final long DEFAULT_RESET_INTERVAL_SEC = 24 * 60 * 60; // 1 day
 148
 149     @VisibleForTesting
 150     static final int DEFAULT_MAX_UPDATES_PER_INTERVAL = 10;
 151
 152     @VisibleForTesting
 153     static final int DEFAULT_MAX_SHORTCUTS_PER_APP = 5;
 154
 155     @VisibleForTesting
 156     static final int DEFAULT_MAX_ICON_DIMENSION_DP = 96;
 157
 158     @VisibleForTesting
 159     static final int DEFAULT_MAX_ICON_DIMENSION_LOWRAM_DP = 48;
 160
 161     @VisibleForTesting
 162     static final String DEFAULT_ICON_PERSIST_FORMAT = CompressFormat.PNG.name();
 163
 164     @VisibleForTesting
 165     static final int DEFAULT_ICON_PERSIST_QUALITY = 100;
 166
 167     @VisibleForTesting
 168     static final int DEFAULT_SAVE_DELAY_MS = 3000;
 169
 170     @VisibleForTesting
 171     static final String FILENAME_BASE_STATE = "shortcut_service.xml";
 172
 173     @VisibleForTesting
 174     static final String DIRECTORY_PER_USER = "shortcut_service";
 175
 176     @VisibleForTesting
 177     static final String FILENAME_USER_PACKAGES = "shortcuts.xml";
 178
 179     static final String DIRECTORY_BITMAPS = "bitmaps";
 180
 181     private static final String TAG_ROOT = "root";
 182     private static final String TAG_LAST_RESET_TIME = "last_reset_time";
 183
 184     private static final String ATTR_VALUE = "value";
 185
 186     private static final String LAUNCHER_INTENT_CATEGORY = Intent.CATEGORY_LAUNCHER;
 187
 188     private static final String KEY_SHORTCUT = "shortcut";
 189     private static final String KEY_LOW_RAM = "lowRam";
 190     private static final String KEY_ICON_SIZE = "iconSize";
 191
 192     @VisibleForTesting
 193     interface ConfigConstants {
 194         /**
 195          * Key name for the save delay, in milliseconds. (int)
 196          */
 197         String KEY_SAVE_DELAY_MILLIS = "save_delay_ms";
 198
 199         /**
 200          * Key name for the throttling reset interval, in seconds. (long)
 201          */
 202         String KEY_RESET_INTERVAL_SEC = "reset_interval_sec";
 203
 204         /**
 205          * Key name for the max number of modifying API calls per app for every interval. (int)
 206          */
 207         String KEY_MAX_UPDATES_PER_INTERVAL = "max_updates_per_interval";
 208
 209         /**
 210          * Key name for the max icon dimensions in DP, for non-low-memory devices.
 211          */
 212         String KEY_MAX_ICON_DIMENSION_DP = "max_icon_dimension_dp";
 213
 214         /**
 215          * Key name for the max icon dimensions in DP, for low-memory devices.
 216          */
 217         String KEY_MAX_ICON_DIMENSION_DP_LOWRAM = "max_icon_dimension_dp_lowram";
 218
 219         /**
 220          * Key name for the max dynamic shortcuts per activity. (int)
 221          */
 222         String KEY_MAX_SHORTCUTS = "max_shortcuts";
 223
 224         /**
 225          * Key name for icon compression quality, 0-100.
 226          */
 227         String KEY_ICON_QUALITY = "icon_quality";
 228
 229         /**
 230          * Key name for icon compression format: "PNG", "JPEG" or "WEBP"
 231          */
 232         String KEY_ICON_FORMAT = "icon_format";
 233     }
 234
 235     final Context mContext;
 236
 237     private final Object mLock = new Object();
 238
 239     private static List<ResolveInfo> EMPTY_RESOLVE_INFO = new ArrayList<>(0);
 240
 241     private static Predicate<ResolveInfo> ACTIVITY_NOT_EXPORTED =
 242             ri -> !ri.activityInfo.exported;
 243
 244     private static Predicate<PackageInfo> PACKAGE_NOT_INSTALLED = pi -> !isInstalled(pi);
 245
 246     private final Handler mHandler;
 247
 248     @GuardedBy("mLock")
 249     private final ArrayList<ShortcutChangeListener> mListeners = new ArrayList<>(1);
 250
 251     @GuardedBy("mLock")
 252     private long mRawLastResetTime;
 253
 254     /**
 255      * User ID -> UserShortcuts
 256      */
 257     @GuardedBy("mLock")
 258     private final SparseArray<ShortcutUser> mUsers = new SparseArray<>();
 259
 260     /**
 261      * Max number of dynamic + manifest shortcuts that each application can have at a time.
 262      */
 263     private int mMaxShortcuts;
 264
 265     /**
 266      * Max number of updating API calls that each application can make during the interval.
 267      */
 268     int mMaxUpdatesPerInterval;
 269
 270     /**
 271      * Actual throttling-reset interval.  By default it's a day.
 272      */
 273     private long mResetInterval;
 274
 275     /**
 276      * Icon max width/height in pixels.
 277      */
 278     private int mMaxIconDimension;
 279
 280     private CompressFormat mIconPersistFormat;
 281     private int mIconPersistQuality;
 282
 283     private int mSaveDelayMillis;
 284
 285     private final IPackageManager mIPackageManager;
 286     private final PackageManagerInternal mPackageManagerInternal;
 287     private final UserManager mUserManager;
 288     private final UsageStatsManagerInternal mUsageStatsManagerInternal;
 289     private final ActivityManagerInternal mActivityManagerInternal;
 290
 291     @GuardedBy("mLock")
 292     final SparseIntArray mUidState = new SparseIntArray();
 293
 294     @GuardedBy("mLock")
 295     final SparseLongArray mUidLastForegroundElapsedTime = new SparseLongArray();
 296
 297     @GuardedBy("mLock")
 298     private List<Integer> mDirtyUserIds = new ArrayList<>();
 299
 300     private final AtomicBoolean mBootCompleted = new AtomicBoolean();
 301
 302     private static final int PACKAGE_MATCH_FLAGS =
 303             PackageManager.MATCH_DIRECT_BOOT_AWARE
 304                     | PackageManager.MATCH_DIRECT_BOOT_UNAWARE
 305                     | PackageManager.MATCH_UNINSTALLED_PACKAGES;
 306
 307     @GuardedBy("mLock")
 308     final SparseBooleanArray mUnlockedUsers = new SparseBooleanArray();
 309
 310     // Stats
 311     @VisibleForTesting
 312     interface Stats {
 313         int GET_DEFAULT_HOME = 0;
 314         int GET_PACKAGE_INFO = 1;
 315         int GET_PACKAGE_INFO_WITH_SIG = 2;
 316         int GET_APPLICATION_INFO = 3;
 317         int LAUNCHER_PERMISSION_CHECK = 4;
 318         int CLEANUP_DANGLING_BITMAPS = 5;
 319         int GET_ACTIVITY_WITH_METADATA = 6;
 320         int GET_INSTALLED_PACKAGES = 7;
 321         int CHECK_PACKAGE_CHANGES = 8;
 322         int GET_APPLICATION_RESOURCES = 9;
 323         int RESOURCE_NAME_LOOKUP = 10;
 324         int GET_LAUNCHER_ACTIVITY = 11;
 325         int CHECK_LAUNCHER_ACTIVITY = 12;
 326         int IS_ACTIVITY_ENABLED = 13;
 327         int PACKAGE_UPDATE_CHECK = 14;
 328         int ASYNC_PRELOAD_USER_DELAY = 15;
 329
 330         int COUNT = ASYNC_PRELOAD_USER_DELAY + 1;
 331     }
 332
 333     private static final String[] STAT_LABELS = {
 334             "getHomeActivities()",
 335             "Launcher permission check",
 336             "getPackageInfo()",
 337             "getPackageInfo(SIG)",
 338             "getApplicationInfo",
 339             "cleanupDanglingBitmaps",
 340             "getActivity+metadata",
 341             "getInstalledPackages",
 342             "checkPackageChanges",
 343             "getApplicationResources",
 344             "resourceNameLookup",
 345             "getLauncherActivity",
 346             "checkLauncherActivity",
 347             "isActivityEnabled",
 348             "packageUpdateCheck",
 349             "asyncPreloadUserDelay"
 350     };
 351
 352     final Object mStatLock = new Object();
 353
 354     @GuardedBy("mStatLock")
 355     private final int[] mCountStats = new int[Stats.COUNT];
 356
 357     @GuardedBy("mStatLock")
 358     private final long[] mDurationStats = new long[Stats.COUNT];
 359
 360     private static final int PROCESS_STATE_FOREGROUND_THRESHOLD =
 361             ActivityManager.PROCESS_STATE_FOREGROUND_SERVICE;
 362
 363     static final int OPERATION_SET = 0;
 364     static final int OPERATION_ADD = 1;
 365     static final int OPERATION_UPDATE = 2;
 366
 367     /** @hide */
 368     @IntDef(value = {
 369             OPERATION_SET,
 370             OPERATION_ADD,
 371             OPERATION_UPDATE
 372     })
 373     @Retention(RetentionPolicy.SOURCE)
 374     @interface ShortcutOperation {
 375     }
 376
 377     @GuardedBy("mLock")
 378     private int mWtfCount = 0;
 379
 380     @GuardedBy("mLock")
 381     private Exception mLastWtfStacktrace;
 382
 383     public ShortcutService(Context context) {
 384         this(context, BackgroundThread.get().getLooper(), /*onyForPackgeManagerApis*/ false);
 385     }
 386
 387     @VisibleForTesting
 388     ShortcutService(Context context, Looper looper, boolean onlyForPackageManagerApis) {
 389         mContext = Preconditions.checkNotNull(context);
 390         LocalServices.addService(ShortcutServiceInternal.class, new LocalService());
 391         mHandler = new Handler(looper);
 392         mIPackageManager = AppGlobals.getPackageManager();
 393         mPackageManagerInternal = Preconditions.checkNotNull(
 394                 LocalServices.getService(PackageManagerInternal.class));
 395         mUserManager = Preconditions.checkNotNull(context.getSystemService(UserManager.class));
 396         mUsageStatsManagerInternal = Preconditions.checkNotNull(
 397                 LocalServices.getService(UsageStatsManagerInternal.class));
 398         mActivityManagerInternal = Preconditions.checkNotNull(
 399                 LocalServices.getService(ActivityManagerInternal.class));
 400
 401         if (onlyForPackageManagerApis) {
 402             return; // Don't do anything further.  For unit tests only.
 403         }
 404
 405         // Register receivers.
 406
 407         // We need to set a priority, so let's just not use PackageMonitor for now.
 408         // TODO Refactor PackageMonitor to support priorities.
 409         final IntentFilter packageFilter = new IntentFilter();
 410         packageFilter.addAction(Intent.ACTION_PACKAGE_ADDED);
 411         packageFilter.addAction(Intent.ACTION_PACKAGE_REMOVED);
 412         packageFilter.addAction(Intent.ACTION_PACKAGE_CHANGED);
 413         packageFilter.addAction(Intent.ACTION_PACKAGE_DATA_CLEARED);
 414         packageFilter.addDataScheme("package");
 415         packageFilter.setPriority(IntentFilter.SYSTEM_HIGH_PRIORITY);
 416         mContext.registerReceiverAsUser(mPackageMonitor, UserHandle.ALL,
 417                 packageFilter, null, mHandler);
 418
 419         final IntentFilter preferedActivityFilter = new IntentFilter();
 420         preferedActivityFilter.addAction(Intent.ACTION_PREFERRED_ACTIVITY_CHANGED);
 421         preferedActivityFilter.setPriority(IntentFilter.SYSTEM_HIGH_PRIORITY);
 422         mContext.registerReceiverAsUser(mPackageMonitor, UserHandle.ALL,
 423                 preferedActivityFilter, null, mHandler);
 424
 425         final IntentFilter localeFilter = new IntentFilter();
 426         localeFilter.addAction(Intent.ACTION_LOCALE_CHANGED);
 427         localeFilter.setPriority(IntentFilter.SYSTEM_HIGH_PRIORITY);
 428         mContext.registerReceiverAsUser(mReceiver, UserHandle.ALL,
 429                 localeFilter, null, mHandler);
 430
 431         injectRegisterUidObserver(mUidObserver, ActivityManager.UID_OBSERVER_PROCSTATE
 432                 | ActivityManager.UID_OBSERVER_GONE);
 433     }
 434
 435     void logDurationStat(int statId, long start) {
 436         synchronized (mStatLock) {
 437             mCountStats[statId]++;
 438             mDurationStats[statId] += (injectElapsedRealtime() - start);
 439         }
 440     }
 441
 442     public String injectGetLocaleTagsForUser(@UserIdInt int userId) {
 443         // TODO This should get the per-user locale.  b/30123329 b/30119489
 444         return LocaleList.getDefault().toLanguageTags();
 445     }
 446
 447     final private IUidObserver mUidObserver = new IUidObserver.Stub() {
 448         @Override
 449         public void onUidStateChanged(int uid, int procState) throws RemoteException {
 450             handleOnUidStateChanged(uid, procState);
 451         }
 452
 453         @Override
 454         public void onUidGone(int uid) throws RemoteException {
 455             handleOnUidStateChanged(uid, ActivityManager.MAX_PROCESS_STATE);
 456         }
 457
 458         @Override
 459         public void onUidActive(int uid) throws RemoteException {
 460         }
 461
 462         @Override
 463         public void onUidIdle(int uid) throws RemoteException {
 464         }
 465     };
 466
 467     void handleOnUidStateChanged(int uid, int procState) {
 468         if (DEBUG_PROCSTATE) {
 469             Slog.d(TAG, "onUidStateChanged: uid=" + uid + " state=" + procState);
 470         }
 471         synchronized (mLock) {
 472             mUidState.put(uid, procState);
 473
 474             // We need to keep track of last time an app comes to foreground.
 475             // See ShortcutPackage.getApiCallCount() for how it's used.
 476             // It doesn't have to be persisted, but it needs to be the elapsed time.
 477             if (isProcessStateForeground(procState)) {
 478                 mUidLastForegroundElapsedTime.put(uid, injectElapsedRealtime());
 479             }
 480         }
 481     }
 482
 483     private boolean isProcessStateForeground(int processState) {
 484         return (processState != ActivityManager.PROCESS_STATE_NONEXISTENT)
 485                 && (processState <= PROCESS_STATE_FOREGROUND_THRESHOLD);
 486     }
 487
 488     boolean isUidForegroundLocked(int uid) {
 489         if (uid == Process.SYSTEM_UID) {
 490             // IUidObserver doesn't report the state of SYSTEM, but it always has bound services,
 491             // so it's foreground anyway.
 492             return true;
 493         }
 494         // First, check with the local cache.
 495         if (isProcessStateForeground(mUidState.get(uid, ActivityManager.MAX_PROCESS_STATE))) {
 496             return true;
 497         }
 498         // If the cache says background, reach out to AM.  Since it'll internally need to hold
 499         // the AM lock, we use it as a last resort.
 500         return isProcessStateForeground(mActivityManagerInternal.getUidProcessState(uid));
 501     }
 502
 503     long getUidLastForegroundElapsedTimeLocked(int uid) {
 504         return mUidLastForegroundElapsedTime.get(uid);
 505     }
 506
 507     /**
 508      * System service lifecycle.
 509      */
 510     public static final class Lifecycle extends SystemService {
 511         final ShortcutService mService;
 512
 513         public Lifecycle(Context context) {
 514             super(context);
 515             mService = new ShortcutService(context);
 516         }
 517
 518         @Override
 519         public void onStart() {
 520             publishBinderService(Context.SHORTCUT_SERVICE, mService);
 521         }
 522
 523         @Override
 524         public void onBootPhase(int phase) {
 525             mService.onBootPhase(phase);
 526         }
 527
 528         @Override
 529         public void onCleanupUser(int userHandle) {
 530             mService.handleCleanupUser(userHandle);
 531         }
 532
 533         @Override
 534         public void onUnlockUser(int userId) {
 535             mService.handleUnlockUser(userId);
 536         }
 537     }
 538
 539     /** lifecycle event */
 540     void onBootPhase(int phase) {
 541         if (DEBUG) {
 542             Slog.d(TAG, "onBootPhase: " + phase);
 543         }
 544         switch (phase) {
 545             case SystemService.PHASE_LOCK_SETTINGS_READY:
 546                 initialize();
 547                 break;
 548             case SystemService.PHASE_BOOT_COMPLETED:
 549                 mBootCompleted.set(true);
 550                 break;
 551         }
 552     }
 553
 554     /** lifecycle event */
 555     void handleUnlockUser(int userId) {
 556         if (DEBUG) {
 557         Slog.d(TAG, "handleUnlockUser: user=" + userId);
 558         }
 559         synchronized (mLock) {
 560             mUnlockedUsers.put(userId, true);
 561         }
 562
 563         // Preload the user data.
 564         // Note, we don't use mHandler here but instead just start a new thread.
 565         // This is because mHandler (which uses com.android.internal.os.BackgroundThread) is very
 566         // busy at this point and this could take hundreds of milliseconds, which would be too
 567         // late since the launcher would already have started.
 568         // So we just create a new thread.  This code runs rarely, so we don't use a thread pool
 569         // or anything.
 570         final long start = injectElapsedRealtime();
 571         injectRunOnNewThread(() -> {
 572             synchronized (mLock) {
 573                 logDurationStat(Stats.ASYNC_PRELOAD_USER_DELAY, start);
 574                 getUserShortcutsLocked(userId);
 575             }
 576         });
 577     }
 578
 579     /** lifecycle event */
 580     void handleCleanupUser(int userId) {
 581         if (DEBUG) {
 582             Slog.d(TAG, "handleCleanupUser: user=" + userId);
 583         }
 584         synchronized (mLock) {
 585             unloadUserLocked(userId);
 586
 587             mUnlockedUsers.put(userId, false);
 588         }
 589     }
 590
 591     private void unloadUserLocked(int userId) {
 592         if (DEBUG) {
 593             Slog.d(TAG, "unloadUserLocked: user=" + userId);
 594         }
 595         // Save all dirty information.
 596         saveDirtyInfo();
 597
 598         // Unload
 599         mUsers.delete(userId);
 600     }
 601
 602     /** Return the base state file name */
 603     private AtomicFile getBaseStateFile() {
 604         final File path = new File(injectSystemDataPath(), FILENAME_BASE_STATE);
 605         path.mkdirs();
 606         return new AtomicFile(path);
 607     }
 608
 609     /**
 610      * Init the instance. (load the state file, etc)
 611      */
 612     private void initialize() {
 613         synchronized (mLock) {
 614             loadConfigurationLocked();
 615             loadBaseStateLocked();
 616         }
 617     }
 618
 619     /**
 620      * Load the configuration from Settings.
 621      */
 622     private void loadConfigurationLocked() {
 623         updateConfigurationLocked(injectShortcutManagerConstants());
 624     }
 625
 626     /**
 627      * Load the configuration from Settings.
 628      */
 629     @VisibleForTesting
 630     boolean updateConfigurationLocked(String config) {
 631         boolean result = true;
 632
 633         final KeyValueListParser parser = new KeyValueListParser(',');
 634         try {
 635             parser.setString(config);
 636         } catch (IllegalArgumentException e) {
 637             // Failed to parse the settings string, log this and move on
 638             // with defaults.
 639             Slog.e(TAG, "Bad shortcut manager settings", e);
 640             result = false;
 641         }
 642
 643         mSaveDelayMillis = Math.max(0, (int) parser.getLong(ConfigConstants.KEY_SAVE_DELAY_MILLIS,
 644                 DEFAULT_SAVE_DELAY_MS));
 645
 646         mResetInterval = Math.max(1, parser.getLong(
 647                 ConfigConstants.KEY_RESET_INTERVAL_SEC, DEFAULT_RESET_INTERVAL_SEC)
 648                 * 1000L);
 649
 650         mMaxUpdatesPerInterval = Math.max(0, (int) parser.getLong(
 651                 ConfigConstants.KEY_MAX_UPDATES_PER_INTERVAL, DEFAULT_MAX_UPDATES_PER_INTERVAL));
 652
 653         mMaxShortcuts = Math.max(0, (int) parser.getLong(
 654                 ConfigConstants.KEY_MAX_SHORTCUTS, DEFAULT_MAX_SHORTCUTS_PER_APP));
 655
 656         final int iconDimensionDp = Math.max(1, injectIsLowRamDevice()
 657                 ? (int) parser.getLong(
 658                 ConfigConstants.KEY_MAX_ICON_DIMENSION_DP_LOWRAM,
 659                 DEFAULT_MAX_ICON_DIMENSION_LOWRAM_DP)
 660                 : (int) parser.getLong(
 661                 ConfigConstants.KEY_MAX_ICON_DIMENSION_DP,
 662                 DEFAULT_MAX_ICON_DIMENSION_DP));
 663
 664         mMaxIconDimension = injectDipToPixel(iconDimensionDp);
 665
 666         mIconPersistFormat = CompressFormat.valueOf(
 667                 parser.getString(ConfigConstants.KEY_ICON_FORMAT, DEFAULT_ICON_PERSIST_FORMAT));
 668
 669         mIconPersistQuality = (int) parser.getLong(
 670                 ConfigConstants.KEY_ICON_QUALITY,
 671                 DEFAULT_ICON_PERSIST_QUALITY);
 672
 673         return result;
 674     }
 675
 676     @VisibleForTesting
 677     String injectShortcutManagerConstants() {
 678         return android.provider.Settings.Global.getString(
 679                 mContext.getContentResolver(),
 680                 android.provider.Settings.Global.SHORTCUT_MANAGER_CONSTANTS);
 681     }
 682
 683     @VisibleForTesting
 684     int injectDipToPixel(int dip) {
 685         return (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, dip,
 686                 mContext.getResources().getDisplayMetrics());
 687     }
 688
 689     // === Persisting ===
 690
 691     @Nullable
 692     static String parseStringAttribute(XmlPullParser parser, String attribute) {
 693         return parser.getAttributeValue(null, attribute);
 694     }
 695
 696     static boolean parseBooleanAttribute(XmlPullParser parser, String attribute) {
 697         return parseLongAttribute(parser, attribute) == 1;
 698     }
 699
 700     static int parseIntAttribute(XmlPullParser parser, String attribute) {
 701         return (int) parseLongAttribute(parser, attribute);
 702     }
 703
 704     static int parseIntAttribute(XmlPullParser parser, String attribute, int def) {
 705         return (int) parseLongAttribute(parser, attribute, def);
 706     }
 707
 708     static long parseLongAttribute(XmlPullParser parser, String attribute) {
 709         return parseLongAttribute(parser, attribute, 0);
 710     }
 711
 712     static long parseLongAttribute(XmlPullParser parser, String attribute, long def) {
 713         final String value = parseStringAttribute(parser, attribute);
 714         if (TextUtils.isEmpty(value)) {
 715             return def;
 716         }
 717         try {
 718             return Long.parseLong(value);
 719         } catch (NumberFormatException e) {
 720             Slog.e(TAG, "Error parsing long " + value);
 721             return def;
 722         }
 723     }
 724
 725     @Nullable
 726     static ComponentName parseComponentNameAttribute(XmlPullParser parser, String attribute) {
 727         final String value = parseStringAttribute(parser, attribute);
 728         if (TextUtils.isEmpty(value)) {
 729             return null;
 730         }
 731         return ComponentName.unflattenFromString(value);
 732     }
 733
 734     @Nullable
 735     static Intent parseIntentAttributeNoDefault(XmlPullParser parser, String attribute) {
 736         final String value = parseStringAttribute(parser, attribute);
 737         Intent parsed = null;
 738         if (!TextUtils.isEmpty(value)) {
 739             try {
 740                 parsed = Intent.parseUri(value, /* flags =*/ 0);
 741             } catch (URISyntaxException e) {
 742                 Slog.e(TAG, "Error parsing intent", e);
 743             }
 744         }
 745         return parsed;
 746     }
 747
 748     @Nullable
 749     static Intent parseIntentAttribute(XmlPullParser parser, String attribute) {
 750         Intent parsed = parseIntentAttributeNoDefault(parser, attribute);
 751         if (parsed == null) {
 752             // Default intent.
 753             parsed = new Intent(Intent.ACTION_VIEW);
 754         }
 755         return parsed;
 756     }
 757
 758     static void writeTagValue(XmlSerializer out, String tag, String value) throws IOException {
 759         if (TextUtils.isEmpty(value)) return;
 760
 761         out.startTag(null, tag);
 762         out.attribute(null, ATTR_VALUE, value);
 763         out.endTag(null, tag);
 764     }
 765
 766     static void writeTagValue(XmlSerializer out, String tag, long value) throws IOException {
 767         writeTagValue(out, tag, Long.toString(value));
 768     }
 769
 770     static void writeTagValue(XmlSerializer out, String tag, ComponentName name) throws IOException {
 771         if (name == null) return;
 772         writeTagValue(out, tag, name.flattenToString());
 773     }
 774
 775     static void writeTagExtra(XmlSerializer out, String tag, PersistableBundle bundle)
 776             throws IOException, XmlPullParserException {
 777         if (bundle == null) return;
 778
 779         out.startTag(null, tag);
 780         bundle.saveToXml(out);
 781         out.endTag(null, tag);
 782     }
 783
 784     static void writeAttr(XmlSerializer out, String name, CharSequence value) throws IOException {
 785         if (TextUtils.isEmpty(value)) return;
 786
 787         out.attribute(null, name, value.toString());
 788     }
 789
 790     static void writeAttr(XmlSerializer out, String name, long value) throws IOException {
 791         writeAttr(out, name, String.valueOf(value));
 792     }
 793
 794     static void writeAttr(XmlSerializer out, String name, boolean value) throws IOException {
 795         if (value) {
 796             writeAttr(out, name, "1");
 797         }
 798     }
 799
 800     static void writeAttr(XmlSerializer out, String name, ComponentName comp) throws IOException {
 801         if (comp == null) return;
 802         writeAttr(out, name, comp.flattenToString());
 803     }
 804
 805     static void writeAttr(XmlSerializer out, String name, Intent intent) throws IOException {
 806         if (intent == null) return;
 807
 808         writeAttr(out, name, intent.toUri(/* flags =*/ 0));
 809     }
 810
 811     @VisibleForTesting
 812     void saveBaseStateLocked() {
 813         final AtomicFile file = getBaseStateFile();
 814         if (DEBUG) {
 815             Slog.d(TAG, "Saving to " + file.getBaseFile());
 816         }
 817
 818         FileOutputStream outs = null;
 819         try {
 820             outs = file.startWrite();
 821
 822             // Write to XML
 823             XmlSerializer out = new FastXmlSerializer();
 824             out.setOutput(outs, StandardCharsets.UTF_8.name());
 825             out.startDocument(null, true);
 826             out.startTag(null, TAG_ROOT);
 827
 828             // Body.
 829             writeTagValue(out, TAG_LAST_RESET_TIME, mRawLastResetTime);
 830
 831             // Epilogue.
 832             out.endTag(null, TAG_ROOT);
 833             out.endDocument();
 834
 835             // Close.
 836             file.finishWrite(outs);
 837         } catch (IOException e) {
 838             Slog.e(TAG, "Failed to write to file " + file.getBaseFile(), e);
 839             file.failWrite(outs);
 840         }
 841     }
 842
 843     private void loadBaseStateLocked() {
 844         mRawLastResetTime = 0;
 845
 846         final AtomicFile file = getBaseStateFile();
 847         if (DEBUG) {
 848             Slog.d(TAG, "Loading from " + file.getBaseFile());
 849         }
 850         try (FileInputStream in = file.openRead()) {
 851             XmlPullParser parser = Xml.newPullParser();
 852             parser.setInput(in, StandardCharsets.UTF_8.name());
 853
 854             int type;
 855             while ((type = parser.next()) != XmlPullParser.END_DOCUMENT) {
 856                 if (type != XmlPullParser.START_TAG) {
 857                     continue;
 858                 }
 859                 final int depth = parser.getDepth();
 860                 // Check the root tag
 861                 final String tag = parser.getName();
 862                 if (depth == 1) {
 863                     if (!TAG_ROOT.equals(tag)) {
 864                         Slog.e(TAG, "Invalid root tag: " + tag);
 865                         return;
 866                     }
 867                     continue;
 868                 }
 869                 // Assume depth == 2
 870                 switch (tag) {
 871                     case TAG_LAST_RESET_TIME:
 872                         mRawLastResetTime = parseLongAttribute(parser, ATTR_VALUE);
 873                         break;
 874                     default:
 875                         Slog.e(TAG, "Invalid tag: " + tag);
 876                         break;
 877                 }
 878             }
 879         } catch (FileNotFoundException e) {
 880             // Use the default
 881         } catch (IOException | XmlPullParserException e) {
 882             Slog.e(TAG, "Failed to read file " + file.getBaseFile(), e);
 883
 884             mRawLastResetTime = 0;
 885         }
 886         // Adjust the last reset time.
 887         getLastResetTimeLocked();
 888     }
 889
 890     @VisibleForTesting
 891     final File getUserFile(@UserIdInt int userId) {
 892         return new File(injectUserDataPath(userId), FILENAME_USER_PACKAGES);
 893     }
 894
 895     private void saveUserLocked(@UserIdInt int userId) {
 896         final File path = getUserFile(userId);
 897         if (DEBUG) {
 898             Slog.d(TAG, "Saving to " + path);
 899         }
 900         path.getParentFile().mkdirs();
 901         final AtomicFile file = new AtomicFile(path);
 902         FileOutputStream os = null;
 903         try {
 904             os = file.startWrite();
 905
 906             saveUserInternalLocked(userId, os, /* forBackup= */ false);
 907
 908             file.finishWrite(os);
 909
 910             // Remove all dangling bitmap files.
 911             cleanupDanglingBitmapDirectoriesLocked(userId);
 912         } catch (XmlPullParserException | IOException e) {
 913             Slog.e(TAG, "Failed to write to file " + file.getBaseFile(), e);
 914             file.failWrite(os);
 915         }
 916     }
 917
 918     private void saveUserInternalLocked(@UserIdInt int userId, OutputStream os,
 919             boolean forBackup) throws IOException, XmlPullParserException {
 920
 921         final BufferedOutputStream bos = new BufferedOutputStream(os);
 922
 923         // Write to XML
 924         XmlSerializer out = new FastXmlSerializer();
 925         out.setOutput(bos, StandardCharsets.UTF_8.name());
 926         out.startDocument(null, true);
 927
 928         getUserShortcutsLocked(userId).saveToXml(out, forBackup);
 929
 930         out.endDocument();
 931
 932         bos.flush();
 933         os.flush();
 934     }
 935
 936     static IOException throwForInvalidTag(int depth, String tag) throws IOException {
 937         throw new IOException(String.format("Invalid tag '%s' found at depth %d", tag, depth));
 938     }
 939
 940     static void warnForInvalidTag(int depth, String tag) throws IOException {
 941         Slog.w(TAG, String.format("Invalid tag '%s' found at depth %d", tag, depth));
 942     }
 943
 944     @Nullable
 945     private ShortcutUser loadUserLocked(@UserIdInt int userId) {
 946         final File path = getUserFile(userId);
 947         if (DEBUG) {
 948             Slog.d(TAG, "Loading from " + path);
 949         }
 950         final AtomicFile file = new AtomicFile(path);
 951
 952         final FileInputStream in;
 953         try {
 954             in = file.openRead();
 955         } catch (FileNotFoundException e) {
 956             if (DEBUG) {
 957                 Slog.d(TAG, "Not found " + path);
 958             }
 959             return null;
 960         }
 961         try {
 962             final ShortcutUser ret = loadUserInternal(userId, in, /* forBackup= */ false);
 963             return ret;
 964         } catch (IOException | XmlPullParserException e) {
 965             Slog.e(TAG, "Failed to read file " + file.getBaseFile(), e);
 966             return null;
 967         } finally {
 968             IoUtils.closeQuietly(in);
 969         }
 970     }
 971
 972     private ShortcutUser loadUserInternal(@UserIdInt int userId, InputStream is,
 973             boolean fromBackup) throws XmlPullParserException, IOException {
 974
 975         final BufferedInputStream bis = new BufferedInputStream(is);
 976
 977         ShortcutUser ret = null;
 978         XmlPullParser parser = Xml.newPullParser();
 979         parser.setInput(bis, StandardCharsets.UTF_8.name());
 980
 981         int type;
 982         while ((type = parser.next()) != XmlPullParser.END_DOCUMENT) {
 983             if (type != XmlPullParser.START_TAG) {
 984                 continue;
 985             }
 986             final int depth = parser.getDepth();
 987
 988             final String tag = parser.getName();
 989             if (DEBUG_LOAD) {
 990                 Slog.d(TAG, String.format("depth=%d type=%d name=%s",
 991                         depth, type, tag));
 992             }
 993             if ((depth == 1) && ShortcutUser.TAG_ROOT.equals(tag)) {
 994                 ret = ShortcutUser.loadFromXml(this, parser, userId, fromBackup);
 995                 continue;
 996             }
 997             throwForInvalidTag(depth, tag);
 998         }
 999         return ret;
1000     }
1001
1002     private void scheduleSaveBaseState() {
1003         scheduleSaveInner(UserHandle.USER_NULL); // Special case -- use USER_NULL for base state.
1004     }
1005
1006     void scheduleSaveUser(@UserIdInt int userId) {
1007         scheduleSaveInner(userId);
1008     }
1009
1010     // In order to re-schedule, we need to reuse the same instance, so keep it in final.
1011     private final Runnable mSaveDirtyInfoRunner = this::saveDirtyInfo;
1012
1013     private void scheduleSaveInner(@UserIdInt int userId) {
1014         if (DEBUG) {
1015             Slog.d(TAG, "Scheduling to save for " + userId);
1016         }
1017         synchronized (mLock) {
1018             if (!mDirtyUserIds.contains(userId)) {
1019                 mDirtyUserIds.add(userId);
1020             }
1021         }
1022         // If already scheduled, remove that and re-schedule in N seconds.
1023         mHandler.removeCallbacks(mSaveDirtyInfoRunner);
1024         mHandler.postDelayed(mSaveDirtyInfoRunner, mSaveDelayMillis);
1025     }
1026
1027     @VisibleForTesting
1028     void saveDirtyInfo() {
1029         if (DEBUG) {
1030             Slog.d(TAG, "saveDirtyInfo");
1031         }
1032         try {
1033             synchronized (mLock) {
1034                 for (int i = mDirtyUserIds.size() - 1; i >= 0; i--) {
1035                     final int userId = mDirtyUserIds.get(i);
1036                     if (userId == UserHandle.USER_NULL) { // USER_NULL for base state.
1037                         saveBaseStateLocked();
1038                     } else {
1039                         saveUserLocked(userId);
1040                     }
1041                 }
1042                 mDirtyUserIds.clear();
1043             }
1044         } catch (Exception e) {
1045             wtf("Exception in saveDirtyInfo", e);
1046         }
1047     }
1048
1049     /** Return the last reset time. */
1050     long getLastResetTimeLocked() {
1051         updateTimesLocked();
1052         return mRawLastResetTime;
1053     }
1054
1055     /** Return the next reset time. */
1056     long getNextResetTimeLocked() {
1057         updateTimesLocked();
1058         return mRawLastResetTime + mResetInterval;
1059     }
1060
1061     static boolean isClockValid(long time) {
1062         return time >= 1420070400; // Thu, 01 Jan 2015 00:00:00 GMT
1063     }
1064
1065     /**
1066      * Update the last reset time.
1067      */
1068     private void updateTimesLocked() {
1069
1070         final long now = injectCurrentTimeMillis();
1071
1072         final long prevLastResetTime = mRawLastResetTime;
1073
1074         if (mRawLastResetTime == 0) { // first launch.
1075             // TODO Randomize??
1076             mRawLastResetTime = now;
1077         } else if (now < mRawLastResetTime) {
1078             // Clock rewound.
1079             if (isClockValid(now)) {
1080                 Slog.w(TAG, "Clock rewound");
1081                 // TODO Randomize??
1082                 mRawLastResetTime = now;
1083             }
1084         } else {
1085             if ((mRawLastResetTime + mResetInterval) <= now) {
1086                 final long offset = mRawLastResetTime % mResetInterval;
1087                 mRawLastResetTime = ((now / mResetInterval) * mResetInterval) + offset;
1088             }
1089         }
1090         if (prevLastResetTime != mRawLastResetTime) {
1091             scheduleSaveBaseState();
1092         }
1093     }
1094
1095     // Requires mLock held, but "Locked" prefix would look weired so we just say "L".
1096     protected boolean isUserUnlockedL(@UserIdInt int userId) {
1097         // First, check the local copy.
1098         if (mUnlockedUsers.get(userId)) {
1099             return true;
1100         }
1101         // If the local copy says the user is locked, check with AM for the actual state, since
1102         // the user might just have been unlocked.
1103         // Note we just don't use isUserUnlockingOrUnlocked() here, because it'll return false
1104         // when the user is STOPPING, which we still want to consider as "unlocked".
1105         final long token = injectClearCallingIdentity();
1106         try {
1107             return mUserManager.isUserUnlockingOrUnlocked(userId);
1108         } finally {
1109             injectRestoreCallingIdentity(token);
1110         }
1111     }
1112
1113     // Requires mLock held, but "Locked" prefix would look weired so we jsut say "L".
1114     void throwIfUserLockedL(@UserIdInt int userId) {
1115         if (!isUserUnlockedL(userId)) {
1116             throw new IllegalStateException("User " + userId + " is locked or not running");
1117         }
1118     }
1119
1120     @GuardedBy("mLock")
1121     @NonNull
1122     private boolean isUserLoadedLocked(@UserIdInt int userId) {
1123         return mUsers.get(userId) != null;
1124     }
1125
1126     /** Return the per-user state. */
1127     @GuardedBy("mLock")
1128     @NonNull
1129     ShortcutUser getUserShortcutsLocked(@UserIdInt int userId) {
1130         if (!isUserUnlockedL(userId)) {
1131             wtf("User still locked");
1132         }
1133
1134         ShortcutUser userPackages = mUsers.get(userId);
1135         if (userPackages == null) {
1136             userPackages = loadUserLocked(userId);
1137             if (userPackages == null) {
1138                 userPackages = new ShortcutUser(this, userId);
1139             }
1140             mUsers.put(userId, userPackages);
1141
1142             // Also when a user's data is first accessed, scan all packages.
1143             checkPackageChanges(userId);
1144         }
1145         return userPackages;
1146     }
1147
1148     void forEachLoadedUserLocked(@NonNull Consumer<ShortcutUser> c) {
1149         for (int i = mUsers.size() - 1; i >= 0; i--) {
1150             c.accept(mUsers.valueAt(i));
1151         }
1152     }
1153
1154     /** Return the per-user per-package state. */
1155     @GuardedBy("mLock")
1156     @NonNull
1157     ShortcutPackage getPackageShortcutsLocked(
1158             @NonNull String packageName, @UserIdInt int userId) {
1159         return getUserShortcutsLocked(userId).getPackageShortcuts(packageName);
1160     }
1161
1162     @GuardedBy("mLock")
1163     @NonNull
1164     ShortcutLauncher getLauncherShortcutsLocked(
1165             @NonNull String packageName, @UserIdInt int ownerUserId,
1166             @UserIdInt int launcherUserId) {
1167         return getUserShortcutsLocked(ownerUserId)
1168                 .getLauncherShortcuts(packageName, launcherUserId);
1169     }
1170
1171     // === Caller validation ===
1172
1173     void removeIcon(@UserIdInt int userId, ShortcutInfo shortcut) {
1174         // Do not remove the actual bitmap file yet, because if the device crashes before saving
1175         // he XML we'd lose the icon.  We just remove all dangling files after saving the XML.
1176         shortcut.setIconResourceId(0);
1177         shortcut.setIconResName(null);
1178         shortcut.clearFlags(ShortcutInfo.FLAG_HAS_ICON_FILE | ShortcutInfo.FLAG_HAS_ICON_RES);
1179     }
1180
1181     public void cleanupBitmapsForPackage(@UserIdInt int userId, String packageName) {
1182         final File packagePath = new File(getUserBitmapFilePath(userId), packageName);
1183         if (!packagePath.isDirectory()) {
1184             return;
1185         }
1186         if (!(FileUtils.deleteContents(packagePath) && packagePath.delete())) {
1187             Slog.w(TAG, "Unable to remove directory " + packagePath);
1188         }
1189     }
1190
1191     private void cleanupDanglingBitmapDirectoriesLocked(@UserIdInt int userId) {
1192         if (DEBUG) {
1193             Slog.d(TAG, "cleanupDanglingBitmaps: userId=" + userId);
1194         }
1195         final long start = injectElapsedRealtime();
1196
1197         final ShortcutUser user = getUserShortcutsLocked(userId);
1198
1199         final File bitmapDir = getUserBitmapFilePath(userId);
1200         final File[] children = bitmapDir.listFiles();
1201         if (children == null) {
1202             return;
1203         }
1204         for (File child : children) {
1205             if (!child.isDirectory()) {
1206                 continue;
1207             }
1208             final String packageName = child.getName();
1209             if (DEBUG) {
1210                 Slog.d(TAG, "cleanupDanglingBitmaps: Found directory=" + packageName);
1211             }
1212             if (!user.hasPackage(packageName)) {
1213                 if (DEBUG) {
1214                     Slog.d(TAG, "Removing dangling bitmap directory: " + packageName);
1215                 }
1216                 cleanupBitmapsForPackage(userId, packageName);
1217             } else {
1218                 cleanupDanglingBitmapFilesLocked(userId, user, packageName, child);
1219             }
1220         }
1221         logDurationStat(Stats.CLEANUP_DANGLING_BITMAPS, start);
1222     }
1223
1224     private void cleanupDanglingBitmapFilesLocked(@UserIdInt int userId, @NonNull ShortcutUser user,
1225             @NonNull String packageName, @NonNull File path) {
1226         final ArraySet<String> usedFiles =
1227                 user.getPackageShortcuts(packageName).getUsedBitmapFiles();
1228
1229         for (File child : path.listFiles()) {
1230             if (!child.isFile()) {
1231                 continue;
1232             }
1233             final String name = child.getName();
1234             if (!usedFiles.contains(name)) {
1235                 if (DEBUG) {
1236                     Slog.d(TAG, "Removing dangling bitmap file: " + child.getAbsolutePath());
1237                 }
1238                 child.delete();
1239             }
1240         }
1241     }
1242
1243     @VisibleForTesting
1244     static class FileOutputStreamWithPath extends FileOutputStream {
1245         private final File mFile;
1246
1247         public FileOutputStreamWithPath(File file) throws FileNotFoundException {
1248             super(file);
1249             mFile = file;
1250         }
1251
1252         public File getFile() {
1253             return mFile;
1254         }
1255     }
1256
1257     /**
1258      * Build the cached bitmap filename for a shortcut icon.
1259      *
1260      * The filename will be based on the ID, except certain characters will be escaped.
1261      */
1262     @VisibleForTesting
1263     FileOutputStreamWithPath openIconFileForWrite(@UserIdInt int userId, ShortcutInfo shortcut)
1264             throws IOException {
1265         final File packagePath = new File(getUserBitmapFilePath(userId),
1266                 shortcut.getPackage());
1267         if (!packagePath.isDirectory()) {
1268             packagePath.mkdirs();
1269             if (!packagePath.isDirectory()) {
1270                 throw new IOException("Unable to create directory " + packagePath);
1271             }
1272             SELinux.restorecon(packagePath);
1273         }
1274
1275         final String baseName = String.valueOf(injectCurrentTimeMillis());
1276         for (int suffix = 0; ; suffix++) {
1277             final String filename = (suffix == 0 ? baseName : baseName + "_" + suffix) + ".png";
1278             final File file = new File(packagePath, filename);
1279             if (!file.exists()) {
1280                 if (DEBUG) {
1281                     Slog.d(TAG, "Saving icon to " + file.getAbsolutePath());
1282                 }
1283                 return new FileOutputStreamWithPath(file);
1284             }
1285         }
1286     }
1287
1288     void saveIconAndFixUpShortcut(@UserIdInt int userId, ShortcutInfo shortcut) {
1289         if (shortcut.hasIconFile() || shortcut.hasIconResource()) {
1290             return;
1291         }
1292
1293         final long token = injectClearCallingIdentity();
1294         try {
1295             // Clear icon info on the shortcut.
1296             removeIcon(userId, shortcut);
1297
1298             final Icon icon = shortcut.getIcon();
1299             if (icon == null) {
1300                 return; // has no icon
1301             }
1302
1303             Bitmap bitmap;
1304             try {
1305                 switch (icon.getType()) {
1306                     case Icon.TYPE_RESOURCE: {
1307                         injectValidateIconResPackage(shortcut, icon);
1308
1309                         shortcut.setIconResourceId(icon.getResId());
1310                         shortcut.addFlags(ShortcutInfo.FLAG_HAS_ICON_RES);
1311                         return;
1312                     }
1313                     case Icon.TYPE_BITMAP: {
1314                         bitmap = icon.getBitmap(); // Don't recycle in this case.
1315                         break;
1316                     }
1317                     default:
1318                         // This shouldn't happen because we've already validated the icon, but
1319                         // just in case.
1320                         throw ShortcutInfo.getInvalidIconException();
1321                 }
1322                 if (bitmap == null) {
1323                     Slog.e(TAG, "Null bitmap detected");
1324                     return;
1325                 }
1326                 // Shrink and write to the file.
1327                 File path = null;
1328                 try {
1329                     final FileOutputStreamWithPath out = openIconFileForWrite(userId, shortcut);
1330                     try {
1331                         path = out.getFile();
1332
1333                         Bitmap shrunk = shrinkBitmap(bitmap, mMaxIconDimension);
1334                         try {
1335                             shrunk.compress(mIconPersistFormat, mIconPersistQuality, out);
1336                         } finally {
1337                             if (bitmap != shrunk) {
1338                                 shrunk.recycle();
1339                             }
1340                         }
1341
1342                         shortcut.setBitmapPath(out.getFile().getAbsolutePath());
1343                         shortcut.addFlags(ShortcutInfo.FLAG_HAS_ICON_FILE);
1344                     } finally {
1345                         IoUtils.closeQuietly(out);
1346                     }
1347                 } catch (IOException | RuntimeException e) {
1348                     // STOPSHIP Change wtf to e
1349                     Slog.wtf(ShortcutService.TAG, "Unable to write bitmap to file", e);
1350                     if (path != null && path.exists()) {
1351                         path.delete();
1352                     }
1353                 }
1354             } finally {
1355                 // Once saved, we won't use the original icon information, so null it out.
1356                 shortcut.clearIcon();
1357             }
1358         } finally {
1359             injectRestoreCallingIdentity(token);
1360         }
1361     }
1362
1363     // Unfortunately we can't do this check in unit tests because we fake creator package names,
1364     // so override in unit tests.
1365     // TODO CTS this case.
1366     void injectValidateIconResPackage(ShortcutInfo shortcut, Icon icon) {
1367         if (!shortcut.getPackage().equals(icon.getResPackage())) {
1368             throw new IllegalArgumentException(
1369                     "Icon resource must reside in shortcut owner package");
1370         }
1371     }
1372
1373     @VisibleForTesting
1374     static Bitmap shrinkBitmap(Bitmap in, int maxSize) {
1375         // Original width/height.
1376         final int ow = in.getWidth();
1377         final int oh = in.getHeight();
1378         if ((ow <= maxSize) && (oh <= maxSize)) {
1379             if (DEBUG) {
1380                 Slog.d(TAG, String.format("Icon size %dx%d, no need to shrink", ow, oh));
1381             }
1382             return in;
1383         }
1384         final int longerDimension = Math.max(ow, oh);
1385
1386         // New width and height.
1387         final int nw = ow * maxSize / longerDimension;
1388         final int nh = oh * maxSize / longerDimension;
1389         if (DEBUG) {
1390             Slog.d(TAG, String.format("Icon size %dx%d, shrinking to %dx%d",
1391                     ow, oh, nw, nh));
1392         }
1393
1394         final Bitmap scaledBitmap = Bitmap.createBitmap(nw, nh, Bitmap.Config.ARGB_8888);
1395         final Canvas c = new Canvas(scaledBitmap);
1396
1397         final RectF dst = new RectF(0, 0, nw, nh);
1398
1399         c.drawBitmap(in, /*src=*/ null, dst, /* paint =*/ null);
1400
1401         return scaledBitmap;
1402     }
1403
1404     /**
1405      * For a shortcut, update all resource names from resource IDs, and also update all
1406      * resource-based strings.
1407      */
1408     void fixUpShortcutResourceNamesAndValues(ShortcutInfo si) {
1409         final Resources publisherRes = injectGetResourcesForApplicationAsUser(
1410                 si.getPackage(), si.getUserId());
1411         if (publisherRes != null) {
1412             final long start = injectElapsedRealtime();
1413             try {
1414                 si.lookupAndFillInResourceNames(publisherRes);
1415             } finally {
1416                 logDurationStat(Stats.RESOURCE_NAME_LOOKUP, start);
1417             }
1418             si.resolveResourceStrings(publisherRes);
1419         }
1420     }
1421
1422     // === Caller validation ===
1423
1424     private boolean isCallerSystem() {
1425         final int callingUid = injectBinderCallingUid();
1426         return UserHandle.isSameApp(callingUid, Process.SYSTEM_UID);
1427     }
1428
1429     private boolean isCallerShell() {
1430         final int callingUid = injectBinderCallingUid();
1431         return callingUid == Process.SHELL_UID || callingUid == Process.ROOT_UID;
1432     }
1433
1434     private void enforceSystemOrShell() {
1435         if (!(isCallerSystem() || isCallerShell())) {
1436             throw new SecurityException("Caller must be system or shell");
1437         }
1438     }
1439
1440     private void enforceShell() {
1441         if (!isCallerShell()) {
1442             throw new SecurityException("Caller must be shell");
1443         }
1444     }
1445
1446     private void enforceSystem() {
1447         if (!isCallerSystem()) {
1448             throw new SecurityException("Caller must be system");
1449         }
1450     }
1451
1452     private void enforceResetThrottlingPermission() {
1453         if (isCallerSystem()) {
1454             return;
1455         }
1456         enforceCallingOrSelfPermission(
1457                 android.Manifest.permission.RESET_SHORTCUT_MANAGER_THROTTLING, null);
1458     }
1459
1460     private void enforceCallingOrSelfPermission(
1461             @NonNull String permission, @Nullable String message) {
1462         if (isCallerSystem()) {
1463             return;
1464         }
1465         injectEnforceCallingPermission(permission, message);
1466     }
1467
1468     /**
1469      * Somehow overriding ServiceContext.enforceCallingPermission() in the unit tests would confuse
1470      * mockito.  So instead we extracted it here and override it in the tests.
1471      */
1472     @VisibleForTesting
1473     void injectEnforceCallingPermission(
1474             @NonNull String permission, @Nullable String message) {
1475         mContext.enforceCallingPermission(permission, message);
1476     }
1477
1478     private void verifyCaller(@NonNull String packageName, @UserIdInt int userId) {
1479         Preconditions.checkStringNotEmpty(packageName, "packageName");
1480
1481         if (isCallerSystem()) {
1482             return; // no check
1483         }
1484
1485         final int callingUid = injectBinderCallingUid();
1486
1487         // Otherwise, make sure the arguments are valid.
1488         if (UserHandle.getUserId(callingUid) != userId) {
1489             throw new SecurityException("Invalid user-ID");
1490         }
1491         if (injectGetPackageUid(packageName, userId) == injectBinderCallingUid()) {
1492             return; // Caller is valid.
1493         }
1494         throw new SecurityException("Calling package name mismatch");
1495     }
1496
1497     // Overridden in unit tests to execute r synchronously.
1498     void injectPostToHandler(Runnable r) {
1499         mHandler.post(r);
1500     }
1501
1502     void injectRunOnNewThread(Runnable r) {
1503         new Thread(r).start();
1504     }
1505
1506     /**
1507      * @throws IllegalArgumentException if {@code numShortcuts} is bigger than
1508      *                                  {@link #getMaxActivityShortcuts()}.
1509      */
1510     void enforceMaxActivityShortcuts(int numShortcuts) {
1511         if (numShortcuts > mMaxShortcuts) {
1512             throw new IllegalArgumentException("Max number of dynamic shortcuts exceeded");
1513         }
1514     }
1515
1516     /**
1517      * Return the max number of dynamic + manifest shortcuts for each launcher icon.
1518      */
1519     int getMaxActivityShortcuts() {
1520         return mMaxShortcuts;
1521     }
1522
1523     /**
1524      * - Sends a notification to LauncherApps
1525      * - Write to file
1526      */
1527     void packageShortcutsChanged(@NonNull String packageName, @UserIdInt int userId) {
1528         if (DEBUG) {
1529             Slog.d(TAG, String.format(
1530                     "Shortcut changes: package=%s, user=%d", packageName, userId));
1531         }
1532         notifyListeners(packageName, userId);
1533         scheduleSaveUser(userId);
1534     }
1535
1536     private void notifyListeners(@NonNull String packageName, @UserIdInt int userId) {
1537         injectPostToHandler(() -> {
1538             try {
1539                 final ArrayList<ShortcutChangeListener> copy;
1540                 synchronized (mLock) {
1541                     if (!isUserUnlockedL(userId)) {
1542                         return;
1543                     }
1544
1545                     copy = new ArrayList<>(mListeners);
1546                 }
1547                 // Note onShortcutChanged() needs to be called with the system service permissions.
1548                 for (int i = copy.size() - 1; i >= 0; i--) {
1549                     copy.get(i).onShortcutChanged(packageName, userId);
1550                 }
1551             } catch (Exception ignore) {
1552             }
1553         });
1554     }
1555
1556     /**
1557      * Clean up / validate an incoming shortcut.
1558      * - Make sure all mandatory fields are set.
1559      * - Make sure the intent's extras are persistable, and them to set
1560      * {@link ShortcutInfo#mIntentPersistableExtrases}.  Also clear its extras.
1561      * - Clear flags.
1562      *
1563      * TODO Detailed unit tests
1564      */
1565     private void fixUpIncomingShortcutInfo(@NonNull ShortcutInfo shortcut, boolean forUpdate) {
1566         Preconditions.checkNotNull(shortcut, "Null shortcut detected");
1567         if (shortcut.getActivity() != null) {
1568             Preconditions.checkState(
1569                     shortcut.getPackage().equals(shortcut.getActivity().getPackageName()),
1570                     "Cannot publish shortcut: activity " + shortcut.getActivity() + " does not"
1571                     + " belong to package " + shortcut.getPackage());
1572             Preconditions.checkState(
1573                     injectIsMainActivity(shortcut.getActivity(), shortcut.getUserId()),
1574                     "Cannot publish shortcut: activity " + shortcut.getActivity() + " is not"
1575                             + " main activity");
1576         }
1577
1578         if (!forUpdate) {
1579             shortcut.enforceMandatoryFields();
1580             Preconditions.checkArgument(
1581                     injectIsMainActivity(shortcut.getActivity(), shortcut.getUserId()),
1582                     "Cannot publish shortcut: " + shortcut.getActivity() + " is not main activity");
1583         }
1584         if (shortcut.getIcon() != null) {
1585             ShortcutInfo.validateIcon(shortcut.getIcon());
1586         }
1587
1588         shortcut.replaceFlags(0);
1589     }
1590
1591     /**
1592      * When a shortcut has no target activity, set the default one from the package.
1593      */
1594     private void fillInDefaultActivity(List<ShortcutInfo> shortcuts) {
1595
1596         ComponentName defaultActivity = null;
1597         for (int i = shortcuts.size() - 1; i >= 0; i--) {
1598             final ShortcutInfo si = shortcuts.get(i);
1599             if (si.getActivity() == null) {
1600                 if (defaultActivity == null) {
1601                     defaultActivity = injectGetDefaultMainActivity(
1602                             si.getPackage(), si.getUserId());
1603                     Preconditions.checkState(defaultActivity != null,
1604                             "Launcher activity not found for package " + si.getPackage());
1605                 }
1606                 si.setActivity(defaultActivity);
1607             }
1608         }
1609     }
1610
1611     private void assignImplicitRanks(List<ShortcutInfo> shortcuts) {
1612         for (int i = shortcuts.size() - 1; i >= 0; i--) {
1613             shortcuts.get(i).setImplicitRank(i);
1614         }
1615     }
1616
1617     // === APIs ===
1618
1619     @Override
1620     public boolean setDynamicShortcuts(String packageName, ParceledListSlice shortcutInfoList,
1621             @UserIdInt int userId) {
1622         verifyCaller(packageName, userId);
1623
1624         final List<ShortcutInfo> newShortcuts = (List<ShortcutInfo>) shortcutInfoList.getList();
1625         final int size = newShortcuts.size();
1626
1627         synchronized (mLock) {
1628             throwIfUserLockedL(userId);
1629
1630             final ShortcutPackage ps = getPackageShortcutsLocked(packageName, userId);
1631             ps.getUser().onCalledByPublisher(packageName);
1632
1633             ps.ensureImmutableShortcutsNotIncluded(newShortcuts);
1634
1635             fillInDefaultActivity(newShortcuts);
1636
1637             ps.enforceShortcutCountsBeforeOperation(newShortcuts, OPERATION_SET);
1638
1639             // Throttling.
1640             if (!ps.tryApiCall()) {
1641                 return false;
1642             }
1643
1644             // Initialize the implicit ranks for ShortcutPackage.adjustRanks().
1645             ps.clearAllImplicitRanks();
1646             assignImplicitRanks(newShortcuts);
1647
1648             for (int i = 0; i < size; i++) {
1649                 fixUpIncomingShortcutInfo(newShortcuts.get(i), /* forUpdate= */ false);
1650             }
1651
1652             // First, remove all un-pinned; dynamic shortcuts
1653             ps.deleteAllDynamicShortcuts();
1654
1655             // Then, add/update all.  We need to make sure to take over "pinned" flag.
1656             for (int i = 0; i < size; i++) {
1657                 final ShortcutInfo newShortcut = newShortcuts.get(i);
1658                 ps.addOrUpdateDynamicShortcut(newShortcut);
1659             }
1660
1661             // Lastly, adjust the ranks.
1662             ps.adjustRanks();
1663         }
1664         packageShortcutsChanged(packageName, userId);
1665
1666         verifyStates();
1667
1668         return true;
1669     }
1670
1671     @Override
1672     public boolean updateShortcuts(String packageName, ParceledListSlice shortcutInfoList,
1673             @UserIdInt int userId) {
1674         verifyCaller(packageName, userId);
1675
1676         final List<ShortcutInfo> newShortcuts = (List<ShortcutInfo>) shortcutInfoList.getList();
1677         final int size = newShortcuts.size();
1678
1679         synchronized (mLock) {
1680             throwIfUserLockedL(userId);
1681
1682             final ShortcutPackage ps = getPackageShortcutsLocked(packageName, userId);
1683             ps.getUser().onCalledByPublisher(packageName);
1684
1685             ps.ensureImmutableShortcutsNotIncluded(newShortcuts);
1686
1687             // For update, don't fill in the default activity.  Having null activity means
1688             // "don't update the activity" here.
1689
1690             ps.enforceShortcutCountsBeforeOperation(newShortcuts, OPERATION_UPDATE);
1691
1692             // Throttling.
1693             if (!ps.tryApiCall()) {
1694                 return false;
1695             }
1696
1697             // Initialize the implicit ranks for ShortcutPackage.adjustRanks().
1698             ps.clearAllImplicitRanks();
1699             assignImplicitRanks(newShortcuts);
1700
1701             for (int i = 0; i < size; i++) {
1702                 final ShortcutInfo source = newShortcuts.get(i);
1703                 fixUpIncomingShortcutInfo(source, /* forUpdate= */ true);
1704
1705                 final ShortcutInfo target = ps.findShortcutById(source.getId());
1706                 if (target == null) {
1707                     continue;
1708                 }
1709
1710                 if (target.isEnabled() != source.isEnabled()) {
1711                     Slog.w(TAG,
1712                             "ShortcutInfo.enabled cannot be changed with updateShortcuts()");
1713                 }
1714
1715                 // When updating the rank, we need to insert between existing ranks, so set
1716                 // this setRankChanged, and also copy the implicit rank fo adjustRanks().
1717                 if (source.hasRank()) {
1718                     target.setRankChanged();
1719                     target.setImplicitRank(source.getImplicitRank());
1720                 }
1721
1722                 final boolean replacingIcon = (source.getIcon() != null);
1723                 if (replacingIcon) {
1724                     removeIcon(userId, target);
1725                 }
1726
1727                 // Note copyNonNullFieldsFrom() does the "updatable with?" check too.
1728                 target.copyNonNullFieldsFrom(source);
1729                 target.setTimestamp(injectCurrentTimeMillis());
1730
1731                 if (replacingIcon) {
1732                     saveIconAndFixUpShortcut(userId, target);
1733                 }
1734
1735                 // When we're updating any resource related fields, re-extract the res names and
1736                 // the values.
1737                 if (replacingIcon || source.hasStringResources()) {
1738                     fixUpShortcutResourceNamesAndValues(target);
1739                 }
1740             }
1741
1742             // Lastly, adjust the ranks.
1743             ps.adjustRanks();
1744         }
1745         packageShortcutsChanged(packageName, userId);
1746
1747         verifyStates();
1748
1749         return true;
1750     }
1751
1752     @Override
1753     public boolean addDynamicShortcuts(String packageName, ParceledListSlice shortcutInfoList,
1754             @UserIdInt int userId) {
1755         verifyCaller(packageName, userId);
1756
1757         final List<ShortcutInfo> newShortcuts = (List<ShortcutInfo>) shortcutInfoList.getList();
1758         final int size = newShortcuts.size();
1759
1760         synchronized (mLock) {
1761             throwIfUserLockedL(userId);
1762
1763             final ShortcutPackage ps = getPackageShortcutsLocked(packageName, userId);
1764             ps.getUser().onCalledByPublisher(packageName);
1765
1766             ps.ensureImmutableShortcutsNotIncluded(newShortcuts);
1767
1768             fillInDefaultActivity(newShortcuts);
1769
1770             ps.enforceShortcutCountsBeforeOperation(newShortcuts, OPERATION_ADD);
1771
1772             // Initialize the implicit ranks for ShortcutPackage.adjustRanks().
1773             ps.clearAllImplicitRanks();
1774             assignImplicitRanks(newShortcuts);
1775
1776             // Throttling.
1777             if (!ps.tryApiCall()) {
1778                 return false;
1779             }
1780             for (int i = 0; i < size; i++) {
1781                 final ShortcutInfo newShortcut = newShortcuts.get(i);
1782
1783                 // Validate the shortcut.
1784                 fixUpIncomingShortcutInfo(newShortcut, /* forUpdate= */ false);
1785
1786                 // When ranks are changing, we need to insert between ranks, so set the
1787                 // "rank changed" flag.
1788                 newShortcut.setRankChanged();
1789
1790                 // Add it.
1791                 ps.addOrUpdateDynamicShortcut(newShortcut);
1792             }
1793
1794             // Lastly, adjust the ranks.
1795             ps.adjustRanks();
1796         }
1797         packageShortcutsChanged(packageName, userId);
1798
1799         verifyStates();
1800
1801         return true;
1802     }
1803
1804     @Override
1805     public void disableShortcuts(String packageName, List shortcutIds,
1806             CharSequence disabledMessage, int disabledMessageResId, @UserIdInt int userId) {
1807         verifyCaller(packageName, userId);
1808         Preconditions.checkNotNull(shortcutIds, "shortcutIds must be provided");
1809
1810         synchronized (mLock) {
1811             throwIfUserLockedL(userId);
1812
1813             final ShortcutPackage ps = getPackageShortcutsLocked(packageName, userId);
1814             ps.getUser().onCalledByPublisher(packageName);
1815
1816             ps.ensureImmutableShortcutsNotIncludedWithIds((List<String>) shortcutIds);
1817
1818             final String disabledMessageString =
1819                     (disabledMessage == null) ? null : disabledMessage.toString();
1820
1821             for (int i = shortcutIds.size() - 1; i >= 0; i--) {
1822                 ps.disableWithId(Preconditions.checkStringNotEmpty((String) shortcutIds.get(i)),
1823                         disabledMessageString, disabledMessageResId,
1824                         /* overrideImmutable=*/ false);
1825             }
1826
1827             // We may have removed dynamic shortcuts which may have left a gap, so adjust the ranks.
1828             ps.adjustRanks();
1829         }
1830         packageShortcutsChanged(packageName, userId);
1831
1832         verifyStates();
1833     }
1834
1835     @Override
1836     public void enableShortcuts(String packageName, List shortcutIds, @UserIdInt int userId) {
1837         verifyCaller(packageName, userId);
1838         Preconditions.checkNotNull(shortcutIds, "shortcutIds must be provided");
1839
1840         synchronized (mLock) {
1841             throwIfUserLockedL(userId);
1842
1843             final ShortcutPackage ps = getPackageShortcutsLocked(packageName, userId);
1844             ps.getUser().onCalledByPublisher(packageName);
1845
1846             ps.ensureImmutableShortcutsNotIncludedWithIds((List<String>) shortcutIds);
1847
1848             for (int i = shortcutIds.size() - 1; i >= 0; i--) {
1849                 ps.enableWithId((String) shortcutIds.get(i));
1850             }
1851         }
1852         packageShortcutsChanged(packageName, userId);
1853
1854         verifyStates();
1855     }
1856
1857     @Override
1858     public void removeDynamicShortcuts(String packageName, List shortcutIds,
1859             @UserIdInt int userId) {
1860         verifyCaller(packageName, userId);
1861         Preconditions.checkNotNull(shortcutIds, "shortcutIds must be provided");
1862
1863         synchronized (mLock) {
1864             throwIfUserLockedL(userId);
1865
1866             final ShortcutPackage ps = getPackageShortcutsLocked(packageName, userId);
1867             ps.getUser().onCalledByPublisher(packageName);
1868
1869             ps.ensureImmutableShortcutsNotIncludedWithIds((List<String>) shortcutIds);
1870
1871             for (int i = shortcutIds.size() - 1; i >= 0; i--) {
1872                 ps.deleteDynamicWithId(
1873                         Preconditions.checkStringNotEmpty((String) shortcutIds.get(i)));
1874             }
1875
1876             // We may have removed dynamic shortcuts which may have left a gap, so adjust the ranks.
1877             ps.adjustRanks();
1878         }
1879         packageShortcutsChanged(packageName, userId);
1880
1881         verifyStates();
1882     }
1883
1884     @Override
1885     public void removeAllDynamicShortcuts(String packageName, @UserIdInt int userId) {
1886         verifyCaller(packageName, userId);
1887
1888         synchronized (mLock) {
1889             throwIfUserLockedL(userId);
1890
1891             final ShortcutPackage ps = getPackageShortcutsLocked(packageName, userId);
1892             ps.getUser().onCalledByPublisher(packageName);
1893             ps.deleteAllDynamicShortcuts();
1894         }
1895         packageShortcutsChanged(packageName, userId);
1896
1897         verifyStates();
1898     }
1899
1900     @Override
1901     public ParceledListSlice<ShortcutInfo> getDynamicShortcuts(String packageName,
1902             @UserIdInt int userId) {
1903         verifyCaller(packageName, userId);
1904
1905         synchronized (mLock) {
1906             throwIfUserLockedL(userId);
1907
1908             return getShortcutsWithQueryLocked(
1909                     packageName, userId, ShortcutInfo.CLONE_REMOVE_FOR_CREATOR,
1910                     ShortcutInfo::isDynamic);
1911         }
1912     }
1913
1914     @Override
1915     public ParceledListSlice<ShortcutInfo> getManifestShortcuts(String packageName,
1916             @UserIdInt int userId) {
1917         verifyCaller(packageName, userId);
1918
1919         synchronized (mLock) {
1920             throwIfUserLockedL(userId);
1921
1922             return getShortcutsWithQueryLocked(
1923                     packageName, userId, ShortcutInfo.CLONE_REMOVE_FOR_CREATOR,
1924                     ShortcutInfo::isManifestShortcut);
1925         }
1926     }
1927
1928     @Override
1929     public ParceledListSlice<ShortcutInfo> getPinnedShortcuts(String packageName,
1930             @UserIdInt int userId) {
1931         verifyCaller(packageName, userId);
1932
1933         synchronized (mLock) {
1934             throwIfUserLockedL(userId);
1935
1936             return getShortcutsWithQueryLocked(
1937                     packageName, userId, ShortcutInfo.CLONE_REMOVE_FOR_CREATOR,
1938                     ShortcutInfo::isPinned);
1939         }
1940     }
1941
1942     private ParceledListSlice<ShortcutInfo> getShortcutsWithQueryLocked(@NonNull String packageName,
1943             @UserIdInt int userId, int cloneFlags, @NonNull Predicate<ShortcutInfo> query) {
1944
1945         final ArrayList<ShortcutInfo> ret = new ArrayList<>();
1946
1947         final ShortcutPackage ps = getPackageShortcutsLocked(packageName, userId);
1948         ps.getUser().onCalledByPublisher(packageName);
1949         ps.findAll(ret, query, cloneFlags);
1950
1951         return new ParceledListSlice<>(ret);
1952     }
1953
1954     @Override
1955     public int getMaxShortcutCountPerActivity(String packageName, @UserIdInt int userId)
1956             throws RemoteException {
1957         verifyCaller(packageName, userId);
1958
1959         return mMaxShortcuts;
1960     }
1961
1962     @Override
1963     public int getRemainingCallCount(String packageName, @UserIdInt int userId) {
1964         verifyCaller(packageName, userId);
1965
1966         synchronized (mLock) {
1967             throwIfUserLockedL(userId);
1968
1969             final ShortcutPackage ps = getPackageShortcutsLocked(packageName, userId);
1970             ps.getUser().onCalledByPublisher(packageName);
1971             return mMaxUpdatesPerInterval - ps.getApiCallCount();
1972         }
1973     }
1974
1975     @Override
1976     public long getRateLimitResetTime(String packageName, @UserIdInt int userId) {
1977         verifyCaller(packageName, userId);
1978
1979         synchronized (mLock) {
1980             throwIfUserLockedL(userId);
1981
1982             return getNextResetTimeLocked();
1983         }
1984     }
1985
1986     @Override
1987     public int getIconMaxDimensions(String packageName, int userId) {
1988         verifyCaller(packageName, userId);
1989
1990         synchronized (mLock) {
1991             return mMaxIconDimension;
1992         }
1993     }
1994
1995     @Override
1996     public void reportShortcutUsed(String packageName, String shortcutId, int userId) {
1997         verifyCaller(packageName, userId);
1998
1999         Preconditions.checkNotNull(shortcutId);
2000
2001         if (DEBUG) {
2002             Slog.d(TAG, String.format("reportShortcutUsed: Shortcut %s package %s used on user %d",
2003                     shortcutId, packageName, userId));
2004         }
2005
2006         synchronized (mLock) {
2007             throwIfUserLockedL(userId);
2008
2009             final ShortcutPackage ps = getPackageShortcutsLocked(packageName, userId);
2010             ps.getUser().onCalledByPublisher(packageName);
2011
2012             if (ps.findShortcutById(shortcutId) == null) {
2013                 Log.w(TAG, String.format("reportShortcutUsed: package %s doesn't have shortcut %s",
2014                         packageName, shortcutId));
2015                 return;
2016             }
2017         }
2018
2019         final long token = injectClearCallingIdentity();
2020         try {
2021             mUsageStatsManagerInternal.reportShortcutUsage(packageName, shortcutId, userId);
2022         } finally {
2023             injectRestoreCallingIdentity(token);
2024         }
2025     }
2026
2027     /**
2028      * Reset all throttling, for developer options and command line.  Only system/shell can call
2029      * it.
2030      */
2031     @Override
2032     public void resetThrottling() {
2033         enforceSystemOrShell();
2034
2035         resetThrottlingInner(getCallingUserId());
2036     }
2037
2038     void resetThrottlingInner(@UserIdInt int userId) {
2039         synchronized (mLock) {
2040             if (!isUserUnlockedL(userId)) {
2041                 Log.w(TAG, "User " + userId + " is locked or not running");
2042                 return;
2043             }
2044
2045             getUserShortcutsLocked(userId).resetThrottling();
2046         }
2047         scheduleSaveUser(userId);
2048         Slog.i(TAG, "ShortcutManager: throttling counter reset for user " + userId);
2049     }
2050
2051     void resetAllThrottlingInner() {
2052         synchronized (mLock) {
2053             mRawLastResetTime = injectCurrentTimeMillis();
2054         }
2055         scheduleSaveBaseState();
2056         Slog.i(TAG, "ShortcutManager: throttling counter reset for all users");
2057     }
2058
2059     @Override
2060     public void onApplicationActive(String packageName, int userId) {
2061         if (DEBUG) {
2062             Slog.d(TAG, "onApplicationActive: package=" + packageName + "  userid=" + userId);
2063         }
2064         enforceResetThrottlingPermission();
2065
2066         synchronized (mLock) {
2067             if (!isUserUnlockedL(userId)) {
2068                 // This is called by system UI, so no need to throw.  Just ignore.
2069                 return;
2070             }
2071
2072             getPackageShortcutsLocked(packageName, userId)
2073                     .resetRateLimitingForCommandLineNoSaving();
2074             saveUserLocked(userId);
2075         }
2076     }
2077
2078     // We override this method in unit tests to do a simpler check.
2079     boolean hasShortcutHostPermission(@NonNull String callingPackage, int userId) {
2080         final long start = injectElapsedRealtime();
2081         try {
2082             return hasShortcutHostPermissionInner(callingPackage, userId);
2083         } finally {
2084             logDurationStat(Stats.LAUNCHER_PERMISSION_CHECK, start);
2085         }
2086     }
2087
2088     // This method is extracted so we can directly call this method from unit tests,
2089     // even when hasShortcutPermission() is overridden.
2090     @VisibleForTesting
2091     boolean hasShortcutHostPermissionInner(@NonNull String callingPackage, int userId) {
2092         synchronized (mLock) {
2093             throwIfUserLockedL(userId);
2094
2095             final ShortcutUser user = getUserShortcutsLocked(userId);
2096
2097             // Always trust the in-memory cache.
2098             final ComponentName cached = user.getCachedLauncher();
2099             if (cached != null) {
2100                 if (cached.getPackageName().equals(callingPackage)) {
2101                     return true;
2102                 }
2103             }
2104             // If the cached one doesn't match, then go ahead
2105
2106             final List<ResolveInfo> allHomeCandidates = new ArrayList<>();
2107
2108             // Default launcher from package manager.
2109             final long startGetHomeActivitiesAsUser = injectElapsedRealtime();
2110             final ComponentName defaultLauncher = mPackageManagerInternal
2111                     .getHomeActivitiesAsUser(allHomeCandidates, userId);
2112             logDurationStat(Stats.GET_DEFAULT_HOME, startGetHomeActivitiesAsUser);
2113
2114             ComponentName detected;
2115             if (defaultLauncher != null) {
2116                 detected = defaultLauncher;
2117                 if (DEBUG) {
2118                     Slog.v(TAG, "Default launcher from PM: " + detected);
2119                 }
2120             } else {
2121                 detected = user.getLastKnownLauncher();
2122
2123                 if (detected != null) {
2124                     if (injectIsActivityEnabledAndExported(detected, userId)) {
2125                         if (DEBUG) {
2126                             Slog.v(TAG, "Cached launcher: " + detected);
2127                         }
2128                     } else {
2129                         Slog.w(TAG, "Cached launcher " + detected + " no longer exists");
2130                         detected = null;
2131                         user.clearLauncher();
2132                     }
2133                 }
2134             }
2135
2136             if (detected == null) {
2137                 // If we reach here, that means it's the first check since the user was created,
2138                 // and there's already multiple launchers and there's no default set.
2139                 // Find the system one with the highest priority.
2140                 // (We need to check the priority too because of FallbackHome in Settings.)
2141                 // If there's no system launcher yet, then no one can access shortcuts, until
2142                 // the user explicitly
2143                 final int size = allHomeCandidates.size();
2144
2145                 int lastPriority = Integer.MIN_VALUE;
2146                 for (int i = 0; i < size; i++) {
2147                     final ResolveInfo ri = allHomeCandidates.get(i);
2148                     if (!ri.activityInfo.applicationInfo.isSystemApp()) {
2149                         continue;
2150                     }
2151                     if (DEBUG) {
2152                         Slog.d(TAG, String.format("hasShortcutPermissionInner: pkg=%s prio=%d",
2153                                 ri.activityInfo.getComponentName(), ri.priority));
2154                     }
2155                     if (ri.priority < lastPriority) {
2156                         continue;
2157                     }
2158                     detected = ri.activityInfo.getComponentName();
2159                     lastPriority = ri.priority;
2160                 }
2161             }
2162
2163             // Update the cache.
2164             user.setLauncher(detected);
2165             if (detected != null) {
2166                 if (DEBUG) {
2167                     Slog.v(TAG, "Detected launcher: " + detected);
2168                 }
2169                 return detected.getPackageName().equals(callingPackage);
2170             } else {
2171                 // Default launcher not found.
2172                 return false;
2173             }
2174         }
2175     }
2176
2177     // === House keeping ===
2178
2179     private void cleanUpPackageForAllLoadedUsers(String packageName, @UserIdInt int packageUserId,
2180             boolean appStillExists) {
2181         synchronized (mLock) {
2182             forEachLoadedUserLocked(user ->
2183                     cleanUpPackageLocked(packageName, user.getUserId(), packageUserId,
2184                             appStillExists));
2185         }
2186     }
2187
2188     /**
2189      * Remove all the information associated with a package.  This will really remove all the
2190      * information, including the restore information (i.e. it'll remove packages even if they're
2191      * shadow).
2192      *
2193      * This is called when an app is uninstalled, or an app gets "clear data"ed.
2194      */
2195     @VisibleForTesting
2196     void cleanUpPackageLocked(String packageName, int owningUserId, int packageUserId,
2197             boolean appStillExists) {
2198         final boolean wasUserLoaded = isUserLoadedLocked(owningUserId);
2199
2200         final ShortcutUser user = getUserShortcutsLocked(owningUserId);
2201         boolean doNotify = false;
2202
2203         // First, remove the package from the package list (if the package is a publisher).
2204         if (packageUserId == owningUserId) {
2205             if (user.removePackage(packageName) != null) {
2206                 doNotify = true;
2207             }
2208         }
2209
2210         // Also remove from the launcher list (if the package is a launcher).
2211         user.removeLauncher(packageUserId, packageName);
2212
2213         // Then remove pinned shortcuts from all launchers.
2214         user.forAllLaunchers(l -> l.cleanUpPackage(packageName, packageUserId));
2215
2216         // Now there may be orphan shortcuts because we removed pinned shortcuts at the previous
2217         // step.  Remove them too.
2218         user.forAllPackages(p -> p.refreshPinnedFlags());
2219
2220         scheduleSaveUser(owningUserId);
2221
2222         if (doNotify) {
2223             notifyListeners(packageName, owningUserId);
2224         }
2225
2226         // If the app still exists (i.e. data cleared), we need to re-publish manifest shortcuts.
2227         if (appStillExists && (packageUserId == owningUserId)) {
2228             // This will do the notification and save when needed, so do it after the above
2229             // notifyListeners.
2230             user.rescanPackageIfNeeded(packageName, /* forceRescan=*/ true);
2231         }
2232
2233         if (!wasUserLoaded) {
2234             // Note this will execute the scheduled save.
2235             unloadUserLocked(owningUserId);
2236         }
2237     }
2238
2239     /**
2240      * Entry point from {@link LauncherApps}.
2241      */
2242     private class LocalService extends ShortcutServiceInternal {
2243
2244         @Override
2245         public List<ShortcutInfo> getShortcuts(int launcherUserId,
2246                 @NonNull String callingPackage, long changedSince,
2247                 @Nullable String packageName, @Nullable List<String> shortcutIds,
2248                 @Nullable ComponentName componentName,
2249                 int queryFlags, int userId) {
2250             final ArrayList<ShortcutInfo> ret = new ArrayList<>();
2251
2252             final boolean cloneKeyFieldOnly =
2253                     ((queryFlags & ShortcutQuery.FLAG_GET_KEY_FIELDS_ONLY) != 0);
2254             final int cloneFlag = cloneKeyFieldOnly ? ShortcutInfo.CLONE_REMOVE_NON_KEY_INFO
2255                     : ShortcutInfo.CLONE_REMOVE_FOR_LAUNCHER;
2256             if (packageName == null) {
2257                 shortcutIds = null; // LauncherAppsService already threw for it though.
2258             }
2259
2260             synchronized (mLock) {
2261                 throwIfUserLockedL(userId);
2262                 throwIfUserLockedL(launcherUserId);
2263
2264                 getLauncherShortcutsLocked(callingPackage, userId, launcherUserId)
2265                         .attemptToRestoreIfNeededAndSave();
2266
2267                 if (packageName != null) {
2268                     getShortcutsInnerLocked(launcherUserId,
2269                             callingPackage, packageName, shortcutIds, changedSince,
2270                             componentName, queryFlags, userId, ret, cloneFlag);
2271                 } else {
2272                     final List<String> shortcutIdsF = shortcutIds;
2273                     getUserShortcutsLocked(userId).forAllPackages(p -> {
2274                         getShortcutsInnerLocked(launcherUserId,
2275                                 callingPackage, p.getPackageName(), shortcutIdsF, changedSince,
2276                                 componentName, queryFlags, userId, ret, cloneFlag);
2277                     });
2278                 }
2279             }
2280             return ret;
2281         }
2282
2283         private void getShortcutsInnerLocked(int launcherUserId, @NonNull String callingPackage,
2284                 @Nullable String packageName, @Nullable List<String> shortcutIds, long changedSince,
2285                 @Nullable ComponentName componentName, int queryFlags,
2286                 int userId, ArrayList<ShortcutInfo> ret, int cloneFlag) {
2287             final ArraySet<String> ids = shortcutIds == null ? null
2288                     : new ArraySet<>(shortcutIds);
2289
2290             final ShortcutPackage p = getUserShortcutsLocked(userId)
2291                     .getPackageShortcutsIfExists(packageName);
2292             if (p == null) {
2293                 return; // No need to instantiate ShortcutPackage.
2294             }
2295
2296             p.findAll(ret,
2297                     (ShortcutInfo si) -> {
2298                         if (si.getLastChangedTimestamp() < changedSince) {
2299                             return false;
2300                         }
2301                         if (ids != null && !ids.contains(si.getId())) {
2302                             return false;
2303                         }
2304                         if (componentName != null) {
2305                             if (si.getActivity() != null
2306                                     && !si.getActivity().equals(componentName)) {
2307                                 return false;
2308                             }
2309                         }
2310                         if (((queryFlags & ShortcutQuery.FLAG_GET_DYNAMIC) != 0)
2311                                 && si.isDynamic()) {
2312                             return true;
2313                         }
2314                         if (((queryFlags & ShortcutQuery.FLAG_GET_PINNED) != 0)
2315                                 && si.isPinned()) {
2316                             return true;
2317                         }
2318                         if (((queryFlags & ShortcutQuery.FLAG_GET_MANIFEST) != 0)
2319                                 && si.isManifestShortcut()) {
2320                             return true;
2321                         }
2322                         return false;
2323                     }, cloneFlag, callingPackage, launcherUserId);
2324         }
2325
2326         @Override
2327         public boolean isPinnedByCaller(int launcherUserId, @NonNull String callingPackage,
2328                 @NonNull String packageName, @NonNull String shortcutId, int userId) {
2329             Preconditions.checkStringNotEmpty(packageName, "packageName");
2330             Preconditions.checkStringNotEmpty(shortcutId, "shortcutId");
2331
2332             synchronized (mLock) {
2333                 throwIfUserLockedL(userId);
2334                 throwIfUserLockedL(launcherUserId);
2335
2336                 getLauncherShortcutsLocked(callingPackage, userId, launcherUserId)
2337                         .attemptToRestoreIfNeededAndSave();
2338
2339                 final ShortcutInfo si = getShortcutInfoLocked(
2340                         launcherUserId, callingPackage, packageName, shortcutId, userId);
2341                 return si != null && si.isPinned();
2342             }
2343         }
2344
2345         private ShortcutInfo getShortcutInfoLocked(
2346                 int launcherUserId, @NonNull String callingPackage,
2347                 @NonNull String packageName, @NonNull String shortcutId, int userId) {
2348             Preconditions.checkStringNotEmpty(packageName, "packageName");
2349             Preconditions.checkStringNotEmpty(shortcutId, "shortcutId");
2350
2351             throwIfUserLockedL(userId);
2352             throwIfUserLockedL(launcherUserId);
2353
2354             final ShortcutPackage p = getUserShortcutsLocked(userId)
2355                     .getPackageShortcutsIfExists(packageName);
2356             if (p == null) {
2357                 return null;
2358             }
2359
2360             final ArrayList<ShortcutInfo> list = new ArrayList<>(1);
2361             p.findAll(list,
2362                     (ShortcutInfo si) -> shortcutId.equals(si.getId()),
2363                     /* clone flags=*/ 0, callingPackage, launcherUserId);
2364             return list.size() == 0 ? null : list.get(0);
2365         }
2366
2367         @Override
2368         public void pinShortcuts(int launcherUserId,
2369                 @NonNull String callingPackage, @NonNull String packageName,
2370                 @NonNull List<String> shortcutIds, int userId) {
2371             // Calling permission must be checked by LauncherAppsImpl.
2372             Preconditions.checkStringNotEmpty(packageName, "packageName");
2373             Preconditions.checkNotNull(shortcutIds, "shortcutIds");
2374
2375             synchronized (mLock) {
2376                 throwIfUserLockedL(userId);
2377                 throwIfUserLockedL(launcherUserId);
2378
2379                 final ShortcutLauncher launcher =
2380                         getLauncherShortcutsLocked(callingPackage, userId, launcherUserId);
2381                 launcher.attemptToRestoreIfNeededAndSave();
2382
2383                 launcher.pinShortcuts(userId, packageName, shortcutIds);
2384             }
2385             packageShortcutsChanged(packageName, userId);
2386
2387             verifyStates();
2388         }
2389
2390         @Override
2391         public Intent[] createShortcutIntents(int launcherUserId,
2392                 @NonNull String callingPackage,
2393                 @NonNull String packageName, @NonNull String shortcutId, int userId) {
2394             // Calling permission must be checked by LauncherAppsImpl.
2395             Preconditions.checkStringNotEmpty(packageName, "packageName can't be empty");
2396             Preconditions.checkStringNotEmpty(shortcutId, "shortcutId can't be empty");
2397
2398             synchronized (mLock) {
2399                 throwIfUserLockedL(userId);
2400                 throwIfUserLockedL(launcherUserId);
2401
2402                 getLauncherShortcutsLocked(callingPackage, userId, launcherUserId)
2403                         .attemptToRestoreIfNeededAndSave();
2404
2405                 // Make sure the shortcut is actually visible to the launcher.
2406                 final ShortcutInfo si = getShortcutInfoLocked(
2407                         launcherUserId, callingPackage, packageName, shortcutId, userId);
2408                 // "si == null" should suffice here, but check the flags too just to make sure.
2409                 if (si == null || !si.isEnabled() || !si.isAlive()) {
2410                     Log.e(TAG, "Shortcut " + shortcutId + " does not exist or disabled");
2411                     return null;
2412                 }
2413                 return si.getIntents();
2414             }
2415         }
2416
2417         @Override
2418         public void addListener(@NonNull ShortcutChangeListener listener) {
2419             synchronized (mLock) {
2420                 mListeners.add(Preconditions.checkNotNull(listener));
2421             }
2422         }
2423
2424         @Override
2425         public int getShortcutIconResId(int launcherUserId, @NonNull String callingPackage,
2426                 @NonNull String packageName, @NonNull String shortcutId, int userId) {
2427             Preconditions.checkNotNull(callingPackage, "callingPackage");
2428             Preconditions.checkNotNull(packageName, "packageName");
2429             Preconditions.checkNotNull(shortcutId, "shortcutId");
2430
2431             synchronized (mLock) {
2432                 throwIfUserLockedL(userId);
2433                 throwIfUserLockedL(launcherUserId);
2434
2435                 getLauncherShortcutsLocked(callingPackage, userId, launcherUserId)
2436                         .attemptToRestoreIfNeededAndSave();
2437
2438                 final ShortcutPackage p = getUserShortcutsLocked(userId)
2439                         .getPackageShortcutsIfExists(packageName);
2440                 if (p == null) {
2441                     return 0;
2442                 }
2443
2444                 final ShortcutInfo shortcutInfo = p.findShortcutById(shortcutId);
2445                 return (shortcutInfo != null && shortcutInfo.hasIconResource())
2446                         ? shortcutInfo.getIconResourceId() : 0;
2447             }
2448         }
2449
2450         @Override
2451         public ParcelFileDescriptor getShortcutIconFd(int launcherUserId,
2452                 @NonNull String callingPackage, @NonNull String packageName,
2453                 @NonNull String shortcutId, int userId) {
2454             Preconditions.checkNotNull(callingPackage, "callingPackage");
2455             Preconditions.checkNotNull(packageName, "packageName");
2456             Preconditions.checkNotNull(shortcutId, "shortcutId");
2457
2458             synchronized (mLock) {
2459                 throwIfUserLockedL(userId);
2460                 throwIfUserLockedL(launcherUserId);
2461
2462                 getLauncherShortcutsLocked(callingPackage, userId, launcherUserId)
2463                         .attemptToRestoreIfNeededAndSave();
2464
2465                 final ShortcutPackage p = getUserShortcutsLocked(userId)
2466                         .getPackageShortcutsIfExists(packageName);
2467                 if (p == null) {
2468                     return null;
2469                 }
2470
2471                 final ShortcutInfo shortcutInfo = p.findShortcutById(shortcutId);
2472                 if (shortcutInfo == null || !shortcutInfo.hasIconFile()) {
2473                     return null;
2474                 }
2475                 try {
2476                     if (shortcutInfo.getBitmapPath() == null) {
2477                         Slog.w(TAG, "null bitmap detected in getShortcutIconFd()");
2478                         return null;
2479                     }
2480                     return ParcelFileDescriptor.open(
2481                             new File(shortcutInfo.getBitmapPath()),
2482                             ParcelFileDescriptor.MODE_READ_ONLY);
2483                 } catch (FileNotFoundException e) {
2484                     Slog.e(TAG, "Icon file not found: " + shortcutInfo.getBitmapPath());
2485                     return null;
2486                 }
2487             }
2488         }
2489
2490         @Override
2491         public boolean hasShortcutHostPermission(int launcherUserId,
2492                 @NonNull String callingPackage) {
2493             return ShortcutService.this.hasShortcutHostPermission(callingPackage, launcherUserId);
2494         }
2495     }
2496
2497     final BroadcastReceiver mReceiver = new BroadcastReceiver() {
2498         @Override
2499         public void onReceive(Context context, Intent intent) {
2500             if (!mBootCompleted.get()) {
2501                 return; // Boot not completed, ignore the broadcast.
2502             }
2503             try {
2504                 if (Intent.ACTION_LOCALE_CHANGED.equals(intent.getAction())) {
2505                     handleLocaleChanged();
2506                 }
2507             } catch (Exception e) {
2508                 wtf("Exception in mReceiver.onReceive", e);
2509             }
2510         }
2511     };
2512
2513     void handleLocaleChanged() {
2514         if (DEBUG) {
2515             Slog.d(TAG, "handleLocaleChanged");
2516         }
2517         scheduleSaveBaseState();
2518
2519         synchronized (mLock) {
2520             final long token = injectClearCallingIdentity();
2521             try {
2522                 forEachLoadedUserLocked(user -> user.detectLocaleChange());
2523             } finally {
2524                 injectRestoreCallingIdentity(token);
2525             }
2526         }
2527     }
2528
2529     /**
2530      * Package event callbacks.
2531      */
2532     @VisibleForTesting
2533     final BroadcastReceiver mPackageMonitor = new BroadcastReceiver() {
2534         @Override
2535         public void onReceive(Context context, Intent intent) {
2536             final int userId  = intent.getIntExtra(Intent.EXTRA_USER_HANDLE, UserHandle.USER_NULL);
2537             if (userId == UserHandle.USER_NULL) {
2538                 Slog.w(TAG, "Intent broadcast does not contain user handle: " + intent);
2539                 return;
2540             }
2541
2542             final String action = intent.getAction();
2543
2544             // This is normally called on Handler, so clearCallingIdentity() isn't needed,
2545             // but we still check it in unit tests.
2546             final long token = injectClearCallingIdentity();
2547             try {
2548                 synchronized (mLock) {
2549                     if (!isUserUnlockedL(userId)) {
2550                         if (DEBUG) {
2551                             Slog.d(TAG, "Ignoring package broadcast " + action
2552                                     + " for locked/stopped user " + userId);
2553                         }
2554                         return;
2555                     }
2556
2557                     // Whenever we get one of those package broadcasts, or get
2558                     // ACTION_PREFERRED_ACTIVITY_CHANGED, we purge the default launcher cache.
2559                     final ShortcutUser user = getUserShortcutsLocked(userId);
2560                     user.clearLauncher();
2561                 }
2562                 if (Intent.ACTION_PREFERRED_ACTIVITY_CHANGED.equals(action)) {
2563                     // Nothing farther to do.
2564                     return;
2565                 }
2566
2567                 final Uri intentUri = intent.getData();
2568                 final String packageName = (intentUri != null) ? intentUri.getSchemeSpecificPart()
2569                         : null;
2570                 if (packageName == null) {
2571                     Slog.w(TAG, "Intent broadcast does not contain package name: " + intent);
2572                     return;
2573                 }
2574
2575                 final boolean replacing = intent.getBooleanExtra(Intent.EXTRA_REPLACING, false);
2576
2577                 switch (action) {
2578                     case Intent.ACTION_PACKAGE_ADDED:
2579                         if (replacing) {
2580                             handlePackageUpdateFinished(packageName, userId);
2581                         } else {
2582                             handlePackageAdded(packageName, userId);
2583                         }
2584                         break;
2585                     case Intent.ACTION_PACKAGE_REMOVED:
2586                         if (!replacing) {
2587                             handlePackageRemoved(packageName, userId);
2588                         }
2589                         break;
2590                     case Intent.ACTION_PACKAGE_CHANGED:
2591                         handlePackageChanged(packageName, userId);
2592
2593                         break;
2594                     case Intent.ACTION_PACKAGE_DATA_CLEARED:
2595                         handlePackageDataCleared(packageName, userId);
2596                         break;
2597                 }
2598             } catch (Exception e) {
2599                 wtf("Exception in mPackageMonitor.onReceive", e);
2600             } finally {
2601                 injectRestoreCallingIdentity(token);
2602             }
2603         }
2604     };
2605
2606     /**
2607      * Called when a user is unlocked.
2608      * - Check all known packages still exist, and otherwise perform cleanup.
2609      * - If a package still exists, check the version code.  If it's been updated, may need to
2610      * update timestamps of its shortcuts.
2611      */
2612     @VisibleForTesting
2613     void checkPackageChanges(@UserIdInt int ownerUserId) {
2614         if (DEBUG) {
2615             Slog.d(TAG, "checkPackageChanges() ownerUserId=" + ownerUserId);
2616         }
2617         if (injectIsSafeModeEnabled()) {
2618             Slog.i(TAG, "Safe mode, skipping checkPackageChanges()");
2619             return;
2620         }
2621
2622         final long start = injectElapsedRealtime();
2623         try {
2624             final ArrayList<PackageWithUser> gonePackages = new ArrayList<>();
2625
2626             synchronized (mLock) {
2627                 final ShortcutUser user = getUserShortcutsLocked(ownerUserId);
2628
2629                 // Find packages that have been uninstalled.
2630                 user.forAllPackageItems(spi -> {
2631                     if (spi.getPackageInfo().isShadow()) {
2632                         return; // Don't delete shadow information.
2633                     }
2634                     if (!isPackageInstalled(spi.getPackageName(), spi.getPackageUserId())) {
2635                         if (DEBUG) {
2636                             Slog.d(TAG, "Uninstalled: " + spi.getPackageName()
2637                                     + " user " + spi.getPackageUserId());
2638                         }
2639                         gonePackages.add(PackageWithUser.of(spi));
2640                     }
2641                 });
2642                 if (gonePackages.size() > 0) {
2643                     for (int i = gonePackages.size() - 1; i >= 0; i--) {
2644                         final PackageWithUser pu = gonePackages.get(i);
2645                         cleanUpPackageLocked(pu.packageName, ownerUserId, pu.userId,
2646                                 /* appStillExists = */ false);
2647                     }
2648                 }
2649
2650                 rescanUpdatedPackagesLocked(ownerUserId, user.getLastAppScanTime(),
2651                         /* forceRescan=*/ false);
2652             }
2653         } finally {
2654             logDurationStat(Stats.CHECK_PACKAGE_CHANGES, start);
2655         }
2656         verifyStates();
2657     }
2658
2659     private void rescanUpdatedPackagesLocked(@UserIdInt int userId, long lastScanTime,
2660             boolean forceRescan) {
2661         final ShortcutUser user = getUserShortcutsLocked(userId);
2662
2663         // Note after each OTA, we'll need to rescan all system apps, as their lastUpdateTime
2664         // is not reliable.
2665         final long now = injectCurrentTimeMillis();
2666         final boolean afterOta =
2667                 !injectBuildFingerprint().equals(user.getLastAppScanOsFingerprint());
2668
2669         // Then for each installed app, publish manifest shortcuts when needed.
2670         forUpdatedPackages(userId, lastScanTime, afterOta, ai -> {
2671             user.attemptToRestoreIfNeededAndSave(this, ai.packageName, userId);
2672             user.rescanPackageIfNeeded(ai.packageName, forceRescan);
2673         });
2674
2675         // Write the time just before the scan, because there may be apps that have just
2676         // been updated, and we want to catch them in the next time.
2677         user.setLastAppScanTime(now);
2678         user.setLastAppScanOsFingerprint(injectBuildFingerprint());
2679         scheduleSaveUser(userId);
2680     }
2681
2682     private void handlePackageAdded(String packageName, @UserIdInt int userId) {
2683         if (DEBUG) {
2684             Slog.d(TAG, String.format("handlePackageAdded: %s user=%d", packageName, userId));
2685         }
2686         synchronized (mLock) {
2687             final ShortcutUser user = getUserShortcutsLocked(userId);
2688             user.attemptToRestoreIfNeededAndSave(this, packageName, userId);
2689             user.rescanPackageIfNeeded(packageName, /* forceRescan=*/ true);
2690         }
2691         verifyStates();
2692     }
2693
2694     private void handlePackageUpdateFinished(String packageName, @UserIdInt int userId) {
2695         if (DEBUG) {
2696             Slog.d(TAG, String.format("handlePackageUpdateFinished: %s user=%d",
2697                     packageName, userId));
2698         }
2699         synchronized (mLock) {
2700             final ShortcutUser user = getUserShortcutsLocked(userId);
2701             user.attemptToRestoreIfNeededAndSave(this, packageName, userId);
2702
2703             if (isPackageInstalled(packageName, userId)) {
2704                 user.rescanPackageIfNeeded(packageName, /* forceRescan=*/ true);
2705             }
2706         }
2707         verifyStates();
2708     }
2709
2710     private void handlePackageRemoved(String packageName, @UserIdInt int packageUserId) {
2711         if (DEBUG) {
2712             Slog.d(TAG, String.format("handlePackageRemoved: %s user=%d", packageName,
2713                     packageUserId));
2714         }
2715         cleanUpPackageForAllLoadedUsers(packageName, packageUserId, /* appStillExists = */ false);
2716
2717         verifyStates();
2718     }
2719
2720     private void handlePackageDataCleared(String packageName, int packageUserId) {
2721         if (DEBUG) {
2722             Slog.d(TAG, String.format("handlePackageDataCleared: %s user=%d", packageName,
2723                     packageUserId));
2724         }
2725         cleanUpPackageForAllLoadedUsers(packageName, packageUserId, /* appStillExists = */ true);
2726
2727         verifyStates();
2728     }
2729
2730     private void handlePackageChanged(String packageName, int packageUserId) {
2731         if (DEBUG) {
2732             Slog.d(TAG, String.format("handlePackageChanged: %s user=%d", packageName,
2733                     packageUserId));
2734         }
2735
2736         // Activities may be disabled or enabled.  Just rescan the package.
2737         synchronized (mLock) {
2738             final ShortcutUser user = getUserShortcutsLocked(packageUserId);
2739
2740             user.rescanPackageIfNeeded(packageName, /* forceRescan=*/ true);
2741         }
2742
2743         verifyStates();
2744     }
2745
2746     // === PackageManager interaction ===
2747
2748     /**
2749      * Returns {@link PackageInfo} unless it's uninstalled or disabled.
2750      */
2751     @Nullable
2752     final PackageInfo getPackageInfoWithSignatures(String packageName, @UserIdInt int userId) {
2753         return getPackageInfo(packageName, userId, true);
2754     }
2755
2756     /**
2757      * Returns {@link PackageInfo} unless it's uninstalled or disabled.
2758      */
2759     @Nullable
2760     final PackageInfo getPackageInfo(String packageName, @UserIdInt int userId) {
2761         return getPackageInfo(packageName, userId, false);
2762     }
2763
2764     int injectGetPackageUid(@NonNull String packageName, @UserIdInt int userId) {
2765         final long token = injectClearCallingIdentity();
2766         try {
2767             return mIPackageManager.getPackageUid(packageName, PACKAGE_MATCH_FLAGS, userId);
2768         } catch (RemoteException e) {
2769             // Shouldn't happen.
2770             Slog.wtf(TAG, "RemoteException", e);
2771             return -1;
2772         } finally {
2773             injectRestoreCallingIdentity(token);
2774         }
2775     }
2776
2777     /**
2778      * Returns {@link PackageInfo} unless it's uninstalled or disabled.
2779      */
2780     @Nullable
2781     @VisibleForTesting
2782     final PackageInfo getPackageInfo(String packageName, @UserIdInt int userId,
2783             boolean getSignatures) {
2784         return isInstalledOrNull(injectPackageInfoWithUninstalled(
2785                 packageName, userId, getSignatures));
2786     }
2787
2788     /**
2789      * Do not use directly; this returns uninstalled packages too.
2790      */
2791     @Nullable
2792     @VisibleForTesting
2793     PackageInfo injectPackageInfoWithUninstalled(String packageName, @UserIdInt int userId,
2794             boolean getSignatures) {
2795         final long start = injectElapsedRealtime();
2796         final long token = injectClearCallingIdentity();
2797         try {
2798             return mIPackageManager.getPackageInfo(
2799                     packageName, PACKAGE_MATCH_FLAGS
2800                             | (getSignatures ? PackageManager.GET_SIGNATURES : 0), userId);
2801         } catch (RemoteException e) {
2802             // Shouldn't happen.
2803             Slog.wtf(TAG, "RemoteException", e);
2804             return null;
2805         } finally {
2806             injectRestoreCallingIdentity(token);
2807
2808             logDurationStat(
2809                     (getSignatures ? Stats.GET_PACKAGE_INFO_WITH_SIG : Stats.GET_PACKAGE_INFO),
2810                     start);
2811         }
2812     }
2813
2814     /**
2815      * Returns {@link ApplicationInfo} unless it's uninstalled or disabled.
2816      */
2817     @Nullable
2818     @VisibleForTesting
2819     final ApplicationInfo getApplicationInfo(String packageName, @UserIdInt int userId) {
2820         return isInstalledOrNull(injectApplicationInfoWithUninstalled(packageName, userId));
2821     }
2822
2823     /**
2824      * Do not use directly; this returns uninstalled packages too.
2825      */
2826     @Nullable
2827     @VisibleForTesting
2828     ApplicationInfo injectApplicationInfoWithUninstalled(
2829             String packageName, @UserIdInt int userId) {
2830         final long start = injectElapsedRealtime();
2831         final long token = injectClearCallingIdentity();
2832         try {
2833             return mIPackageManager.getApplicationInfo(packageName, PACKAGE_MATCH_FLAGS, userId);
2834         } catch (RemoteException e) {
2835             // Shouldn't happen.
2836             Slog.wtf(TAG, "RemoteException", e);
2837             return null;
2838         } finally {
2839             injectRestoreCallingIdentity(token);
2840
2841             logDurationStat(Stats.GET_APPLICATION_INFO, start);
2842         }
2843     }
2844
2845     /**
2846      * Returns {@link ActivityInfo} with its metadata unless it's uninstalled or disabled.
2847      */
2848     @Nullable
2849     final ActivityInfo getActivityInfoWithMetadata(ComponentName activity, @UserIdInt int userId) {
2850         return isInstalledOrNull(injectGetActivityInfoWithMetadataWithUninstalled(
2851                 activity, userId));
2852     }
2853
2854     /**
2855      * Do not use directly; this returns uninstalled packages too.
2856      */
2857     @Nullable
2858     @VisibleForTesting
2859     ActivityInfo injectGetActivityInfoWithMetadataWithUninstalled(
2860             ComponentName activity, @UserIdInt int userId) {
2861         final long start = injectElapsedRealtime();
2862         final long token = injectClearCallingIdentity();
2863         try {
2864             return mIPackageManager.getActivityInfo(activity,
2865                     (PACKAGE_MATCH_FLAGS | PackageManager.GET_META_DATA), userId);
2866         } catch (RemoteException e) {
2867             // Shouldn't happen.
2868             Slog.wtf(TAG, "RemoteException", e);
2869             return null;
2870         } finally {
2871             injectRestoreCallingIdentity(token);
2872
2873             logDurationStat(Stats.GET_ACTIVITY_WITH_METADATA, start);
2874         }
2875     }
2876
2877     /**
2878      * Return all installed and enabled packages.
2879      */
2880     @NonNull
2881     @VisibleForTesting
2882     final List<PackageInfo> getInstalledPackages(@UserIdInt int userId) {
2883         final long start = injectElapsedRealtime();
2884         final long token = injectClearCallingIdentity();
2885         try {
2886             final List<PackageInfo> all = injectGetPackagesWithUninstalled(userId);
2887
2888             all.removeIf(PACKAGE_NOT_INSTALLED);
2889
2890             return all;
2891         } catch (RemoteException e) {
2892             // Shouldn't happen.
2893             Slog.wtf(TAG, "RemoteException", e);
2894             return null;
2895         } finally {
2896             injectRestoreCallingIdentity(token);
2897
2898             logDurationStat(Stats.GET_INSTALLED_PACKAGES, start);
2899         }
2900     }
2901
2902     /**
2903      * Do not use directly; this returns uninstalled packages too.
2904      */
2905     @NonNull
2906     @VisibleForTesting
2907     List<PackageInfo> injectGetPackagesWithUninstalled(@UserIdInt int userId)
2908             throws RemoteException {
2909         final ParceledListSlice<PackageInfo> parceledList =
2910                 mIPackageManager.getInstalledPackages(PACKAGE_MATCH_FLAGS, userId);
2911         if (parceledList == null) {
2912             return Collections.emptyList();
2913         }
2914         return parceledList.getList();
2915     }
2916
2917     private void forUpdatedPackages(@UserIdInt int userId, long lastScanTime, boolean afterOta,
2918             Consumer<ApplicationInfo> callback) {
2919         if (DEBUG) {
2920             Slog.d(TAG, "forUpdatedPackages for user " + userId + ", lastScanTime=" + lastScanTime);
2921         }
2922         final List<PackageInfo> list = getInstalledPackages(userId);
2923         for (int i = list.size() - 1; i >= 0; i--) {
2924             final PackageInfo pi = list.get(i);
2925
2926             // If the package has been updated since the last scan time, then scan it.
2927             // Also if it's a system app with no update, lastUpdateTime is not reliable, so
2928             // just scan it.
2929             if (pi.lastUpdateTime >= lastScanTime
2930                     || (afterOta && isPureSystemApp(pi.applicationInfo))) {
2931                 if (DEBUG) {
2932                     Slog.d(TAG, "Found updated package " + pi.packageName);
2933                 }
2934                 callback.accept(pi.applicationInfo);
2935             }
2936         }
2937     }
2938
2939     /**
2940      * @return true if it's a system app with no updates.
2941      */
2942     private boolean isPureSystemApp(ApplicationInfo ai) {
2943         return ai.isSystemApp() && !ai.isUpdatedSystemApp();
2944     }
2945
2946     private boolean isApplicationFlagSet(@NonNull String packageName, int userId, int flags) {
2947         final ApplicationInfo ai = injectApplicationInfoWithUninstalled(packageName, userId);
2948         return (ai != null) && ((ai.flags & flags) == flags);
2949     }
2950
2951     private static boolean isInstalled(@Nullable ApplicationInfo ai) {
2952         return (ai != null) && (ai.flags & ApplicationInfo.FLAG_INSTALLED) != 0;
2953     }
2954
2955     private static boolean isInstalled(@Nullable PackageInfo pi) {
2956         return (pi != null) && isInstalled(pi.applicationInfo);
2957     }
2958
2959     private static boolean isInstalled(@Nullable ActivityInfo ai) {
2960         return (ai != null) && isInstalled(ai.applicationInfo);
2961     }
2962
2963     private static ApplicationInfo isInstalledOrNull(ApplicationInfo ai) {
2964         return isInstalled(ai) ? ai : null;
2965     }
2966
2967     private static PackageInfo isInstalledOrNull(PackageInfo pi) {
2968         return isInstalled(pi) ? pi : null;
2969     }
2970
2971     private static ActivityInfo isInstalledOrNull(ActivityInfo ai) {
2972         return isInstalled(ai) ? ai : null;
2973     }
2974
2975     boolean isPackageInstalled(String packageName, int userId) {
2976         return getApplicationInfo(packageName, userId) != null;
2977     }
2978
2979     @Nullable
2980     XmlResourceParser injectXmlMetaData(ActivityInfo activityInfo, String key) {
2981         return activityInfo.loadXmlMetaData(mContext.getPackageManager(), key);
2982     }
2983
2984     @Nullable
2985     Resources injectGetResourcesForApplicationAsUser(String packageName, int userId) {
2986         final long start = injectElapsedRealtime();
2987         final long token = injectClearCallingIdentity();
2988         try {
2989             return mContext.getPackageManager().getResourcesForApplicationAsUser(
2990                     packageName, userId);
2991         } catch (NameNotFoundException e) {
2992             Slog.e(TAG, "Resources for package " + packageName + " not found");
2993             return null;
2994         } finally {
2995             injectRestoreCallingIdentity(token);
2996
2997             logDurationStat(Stats.GET_APPLICATION_RESOURCES, start);
2998         }
2999     }
3000
3001     private Intent getMainActivityIntent() {
3002         final Intent intent = new Intent(Intent.ACTION_MAIN);
3003         intent.addCategory(LAUNCHER_INTENT_CATEGORY);
3004         return intent;
3005     }
3006
3007     /**
3008      * Same as queryIntentActivitiesAsUser, except it makes sure the package is installed,
3009      * and only returns exported activities.
3010      */
3011     @NonNull
3012     @VisibleForTesting
3013     List<ResolveInfo> queryActivities(@NonNull Intent baseIntent,
3014             @NonNull String packageName, @Nullable ComponentName activity, int userId) {
3015
3016         baseIntent.setPackage(Preconditions.checkNotNull(packageName));
3017         if (activity != null) {
3018             baseIntent.setComponent(activity);
3019         }
3020
3021         final List<ResolveInfo> resolved =
3022                 mContext.getPackageManager().queryIntentActivitiesAsUser(
3023                         baseIntent, PACKAGE_MATCH_FLAGS, userId);
3024         if (resolved == null || resolved.size() == 0) {
3025             return EMPTY_RESOLVE_INFO;
3026         }
3027         // Make sure the package is installed.
3028         if (!isInstalled(resolved.get(0).activityInfo)) {
3029             return EMPTY_RESOLVE_INFO;
3030         }
3031         resolved.removeIf(ACTIVITY_NOT_EXPORTED);
3032         return resolved;
3033     }
3034
3035     /**
3036      * Return the main activity that is enabled and exported.  If multiple activities are found,
3037      * return the first one.
3038      */
3039     @Nullable
3040     ComponentName injectGetDefaultMainActivity(@NonNull String packageName, int userId) {
3041         final long start = injectElapsedRealtime();
3042         final long token = injectClearCallingIdentity();
3043         try {
3044             final List<ResolveInfo> resolved =
3045                     queryActivities(getMainActivityIntent(), packageName, null, userId);
3046             return resolved.size() == 0 ? null : resolved.get(0).activityInfo.getComponentName();
3047         } finally {
3048             injectRestoreCallingIdentity(token);
3049
3050             logDurationStat(Stats.GET_LAUNCHER_ACTIVITY, start);
3051         }
3052     }
3053
3054     /**
3055      * Return whether an activity is enabled, exported and main.
3056      */
3057     boolean injectIsMainActivity(@NonNull ComponentName activity, int userId) {
3058         final long start = injectElapsedRealtime();
3059         final long token = injectClearCallingIdentity();
3060         try {
3061             final List<ResolveInfo> resolved =
3062                     queryActivities(getMainActivityIntent(), activity.getPackageName(),
3063                             activity, userId);
3064             return resolved.size() > 0;
3065         } finally {
3066             injectRestoreCallingIdentity(token);
3067
3068             logDurationStat(Stats.CHECK_LAUNCHER_ACTIVITY, start);
3069         }
3070     }
3071
3072     /**
3073      * Return all the enabled, exported and main activities from a package.
3074      */
3075     @NonNull
3076     List<ResolveInfo> injectGetMainActivities(@NonNull String packageName, int userId) {
3077         final long start = injectElapsedRealtime();
3078         final long token = injectClearCallingIdentity();
3079         try {
3080             return queryActivities(getMainActivityIntent(), packageName, null, userId);
3081         } finally {
3082             injectRestoreCallingIdentity(token);
3083
3084             logDurationStat(Stats.CHECK_LAUNCHER_ACTIVITY, start);
3085         }
3086     }
3087
3088     /**
3089      * Return whether an activity is enabled and exported.
3090      */
3091     @VisibleForTesting
3092     boolean injectIsActivityEnabledAndExported(
3093             @NonNull ComponentName activity, @UserIdInt int userId) {
3094         final long start = injectElapsedRealtime();
3095         final long token = injectClearCallingIdentity();
3096         try {
3097             return queryActivities(new Intent(), activity.getPackageName(), activity, userId)
3098                     .size() > 0;
3099         } finally {
3100             injectRestoreCallingIdentity(token);
3101
3102             logDurationStat(Stats.IS_ACTIVITY_ENABLED, start);
3103         }
3104     }
3105
3106     boolean injectIsSafeModeEnabled() {
3107         final long token = injectClearCallingIdentity();
3108         try {
3109             return IWindowManager.Stub
3110                     .asInterface(ServiceManager.getService(Context.WINDOW_SERVICE))
3111                     .isSafeModeEnabled();
3112         } catch (RemoteException e) {
3113             return false; // Shouldn't happen though.
3114         } finally {
3115             injectRestoreCallingIdentity(token);
3116         }
3117     }
3118
3119     // === Backup & restore ===
3120
3121     boolean shouldBackupApp(String packageName, int userId) {
3122         return isApplicationFlagSet(packageName, userId, ApplicationInfo.FLAG_ALLOW_BACKUP);
3123     }
3124
3125     boolean shouldBackupApp(PackageInfo pi) {
3126         return (pi.applicationInfo.flags & ApplicationInfo.FLAG_ALLOW_BACKUP) != 0;
3127     }
3128
3129     @Override
3130     public byte[] getBackupPayload(@UserIdInt int userId) {
3131         enforceSystem();
3132         if (DEBUG) {
3133             Slog.d(TAG, "Backing up user " + userId);
3134         }
3135         synchronized (mLock) {
3136             if (!isUserUnlockedL(userId)) {
3137                 wtf("Can't backup: user " + userId + " is locked or not running");
3138                 return null;
3139             }
3140
3141             final ShortcutUser user = getUserShortcutsLocked(userId);
3142             if (user == null) {
3143                 wtf("Can't backup: user not found: id=" + userId);
3144                 return null;
3145             }
3146
3147             user.forAllPackageItems(spi -> spi.refreshPackageInfoAndSave());
3148
3149             // Then save.
3150             final ByteArrayOutputStream os = new ByteArrayOutputStream(32 * 1024);
3151             try {
3152                 saveUserInternalLocked(userId, os, /* forBackup */ true);
3153             } catch (XmlPullParserException | IOException e) {
3154                 // Shouldn't happen.
3155                 Slog.w(TAG, "Backup failed.", e);
3156                 return null;
3157             }
3158             return os.toByteArray();
3159         }
3160     }
3161
3162     @Override
3163     public void applyRestore(byte[] payload, @UserIdInt int userId) {
3164         enforceSystem();
3165         if (DEBUG) {
3166             Slog.d(TAG, "Restoring user " + userId);
3167         }
3168         synchronized (mLock) {
3169             if (!isUserUnlockedL(userId)) {
3170                 wtf("Can't restore: user " + userId + " is locked or not running");
3171                 return;
3172             }
3173             final ShortcutUser user;
3174             final ByteArrayInputStream is = new ByteArrayInputStream(payload);
3175             try {
3176                 user = loadUserInternal(userId, is, /* fromBackup */ true);
3177             } catch (XmlPullParserException | IOException e) {
3178                 Slog.w(TAG, "Restoration failed.", e);
3179                 return;
3180             }
3181             mUsers.put(userId, user);
3182
3183             // Rescan all packages to re-publish manifest shortcuts and do other checks.
3184             rescanUpdatedPackagesLocked(userId,
3185                     0, // lastScanTime = 0; rescan all packages.
3186                     /* forceRescan= */ true);
3187
3188             saveUserLocked(userId);
3189         }
3190     }
3191
3192     // === Dump ===
3193
3194     @Override
3195     public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
3196         enforceCallingOrSelfPermission(android.Manifest.permission.DUMP,
3197                 "can't dump by this caller");
3198         boolean checkin = false;
3199         boolean clear = false;
3200         if (args != null) {
3201             for (String arg : args) {
3202                 if ("-c".equals(arg)) {
3203                     checkin = true;
3204                 } else if ("--checkin".equals(arg)) {
3205                     checkin = true;
3206                     clear = true;
3207                 }
3208             }
3209         }
3210
3211         if (checkin) {
3212             dumpCheckin(pw, clear);
3213         } else {
3214             dumpInner(pw);
3215         }
3216     }
3217
3218     private void dumpInner(PrintWriter pw) {
3219         synchronized (mLock) {
3220             final long now = injectCurrentTimeMillis();
3221             pw.print("Now: [");
3222             pw.print(now);
3223             pw.print("] ");
3224             pw.print(formatTime(now));
3225
3226             pw.print("  Raw last reset: [");
3227             pw.print(mRawLastResetTime);
3228             pw.print("] ");
3229             pw.print(formatTime(mRawLastResetTime));
3230
3231             final long last = getLastResetTimeLocked();
3232             pw.print("  Last reset: [");
3233             pw.print(last);
3234             pw.print("] ");
3235             pw.print(formatTime(last));
3236
3237             final long next = getNextResetTimeLocked();
3238             pw.print("  Next reset: [");
3239             pw.print(next);
3240             pw.print("] ");
3241             pw.print(formatTime(next));
3242
3243             pw.print("  Config:");
3244             pw.print("    Max icon dim: ");
3245             pw.println(mMaxIconDimension);
3246             pw.print("    Icon format: ");
3247             pw.println(mIconPersistFormat);
3248             pw.print("    Icon quality: ");
3249             pw.println(mIconPersistQuality);
3250             pw.print("    saveDelayMillis: ");
3251             pw.println(mSaveDelayMillis);
3252             pw.print("    resetInterval: ");
3253             pw.println(mResetInterval);
3254             pw.print("    maxUpdatesPerInterval: ");
3255             pw.println(mMaxUpdatesPerInterval);
3256             pw.print("    maxShortcutsPerActivity: ");
3257             pw.println(mMaxShortcuts);
3258             pw.println();
3259
3260             pw.println("  Stats:");
3261             synchronized (mStatLock) {
3262                 for (int i = 0; i < Stats.COUNT; i++) {
3263                     dumpStatLS(pw, "    ", i);
3264                 }
3265             }
3266
3267             pw.println();
3268             pw.print("  #Failures: ");
3269             pw.println(mWtfCount);
3270
3271             if (mLastWtfStacktrace != null) {
3272                 pw.print("  Last failure stack trace: ");
3273                 pw.println(Log.getStackTraceString(mLastWtfStacktrace));
3274             }
3275
3276             for (int i = 0; i < mUsers.size(); i++) {
3277                 pw.println();
3278                 mUsers.valueAt(i).dump(pw, "  ");
3279             }
3280
3281             pw.println();
3282             pw.println("  UID state:");
3283
3284             for (int i = 0; i < mUidState.size(); i++) {
3285                 final int uid = mUidState.keyAt(i);
3286                 final int state = mUidState.valueAt(i);
3287                 pw.print("    UID=");
3288                 pw.print(uid);
3289                 pw.print(" state=");
3290                 pw.print(state);
3291                 if (isProcessStateForeground(state)) {
3292                     pw.print("  [FG]");
3293                 }
3294                 pw.print("  last FG=");
3295                 pw.print(mUidLastForegroundElapsedTime.get(uid));
3296                 pw.println();
3297             }
3298         }
3299     }
3300
3301     static String formatTime(long time) {
3302         Time tobj = new Time();
3303         tobj.set(time);
3304         return tobj.format("%Y-%m-%d %H:%M:%S");
3305     }
3306
3307     private void dumpStatLS(PrintWriter pw, String prefix, int statId) {
3308         pw.print(prefix);
3309         final int count = mCountStats[statId];
3310         final long dur = mDurationStats[statId];
3311         pw.println(String.format("%s: count=%d, total=%dms, avg=%.1fms",
3312                 STAT_LABELS[statId], count, dur,
3313                 (count == 0 ? 0 : ((double) dur) / count)));
3314     }
3315
3316     /**
3317      * Dumpsys for checkin.
3318      *
3319      * @param clear if true, clear the history information.  Some other system services have this
3320      * behavior but shortcut service doesn't for now.
3321      */
3322     private  void dumpCheckin(PrintWriter pw, boolean clear) {
3323         synchronized (mLock) {
3324             try {
3325                 final JSONArray users = new JSONArray();
3326
3327                 for (int i = 0; i < mUsers.size(); i++) {
3328                     users.put(mUsers.valueAt(i).dumpCheckin(clear));
3329                 }
3330
3331                 final JSONObject result = new JSONObject();
3332
3333                 result.put(KEY_SHORTCUT, users);
3334                 result.put(KEY_LOW_RAM, injectIsLowRamDevice());
3335                 result.put(KEY_ICON_SIZE, mMaxIconDimension);
3336
3337                 pw.println(result.toString(1));
3338             } catch (JSONException e) {
3339                 Slog.e(TAG, "Unable to write in json", e);
3340             }
3341         }
3342     }
3343
3344     // === Shell support ===
3345
3346     @Override
3347     public void onShellCommand(FileDescriptor in, FileDescriptor out, FileDescriptor err,
3348             String[] args, ResultReceiver resultReceiver) throws RemoteException {
3349
3350         enforceShell();
3351
3352         final long token = injectClearCallingIdentity();
3353         try {
3354             final int status = (new MyShellCommand()).exec(this, in, out, err, args, resultReceiver);
3355             resultReceiver.send(status, null);
3356         } finally {
3357             injectRestoreCallingIdentity(token);
3358         }
3359     }
3360
3361     static class CommandException extends Exception {
3362         public CommandException(String message) {
3363             super(message);
3364         }
3365     }
3366
3367     /**
3368      * Handle "adb shell cmd".
3369      */
3370     private class MyShellCommand extends ShellCommand {
3371
3372         private int mUserId = UserHandle.USER_SYSTEM;
3373
3374         private void parseOptionsLocked(boolean takeUser)
3375                 throws CommandException {
3376             String opt;
3377             while ((opt = getNextOption()) != null) {
3378                 switch (opt) {
3379                     case "--user":
3380                         if (takeUser) {
3381                             mUserId = UserHandle.parseUserArg(getNextArgRequired());
3382                             if (!isUserUnlockedL(mUserId)) {
3383                                 throw new CommandException(
3384                                         "User " + mUserId + " is not running or locked");
3385                             }
3386                             break;
3387                         }
3388                         // fallthrough
3389                     default:
3390                         throw new CommandException("Unknown option: " + opt);
3391                 }
3392             }
3393         }
3394
3395         @Override
3396         public int onCommand(String cmd) {
3397             if (cmd == null) {
3398                 return handleDefaultCommands(cmd);
3399             }
3400             final PrintWriter pw = getOutPrintWriter();
3401             try {
3402                 switch (cmd) {
3403                     case "reset-throttling":
3404                         handleResetThrottling();
3405                         break;
3406                     case "reset-all-throttling":
3407                         handleResetAllThrottling();
3408                         break;
3409                     case "override-config":
3410                         handleOverrideConfig();
3411                         break;
3412                     case "reset-config":
3413                         handleResetConfig();
3414                         break;
3415                     case "clear-default-launcher":
3416                         handleClearDefaultLauncher();
3417                         break;
3418                     case "get-default-launcher":
3419                         handleGetDefaultLauncher();
3420                         break;
3421                     case "unload-user":
3422                         handleUnloadUser();
3423                         break;
3424                     case "clear-shortcuts":
3425                         handleClearShortcuts();
3426                         break;
3427                     case "verify-states": // hidden command to verify various internal states.
3428                         handleVerifyStates();
3429                         break;
3430                     default:
3431                         return handleDefaultCommands(cmd);
3432                 }
3433             } catch (CommandException e) {
3434                 pw.println("Error: " + e.getMessage());
3435                 return 1;
3436             }
3437             pw.println("Success");
3438             return 0;
3439         }
3440
3441         @Override
3442         public void onHelp() {
3443             final PrintWriter pw = getOutPrintWriter();
3444             pw.println("Usage: cmd shortcut COMMAND [options ...]");
3445             pw.println();
3446             pw.println("cmd shortcut reset-throttling [--user USER_ID]");
3447             pw.println("    Reset throttling for all packages and users");
3448             pw.println();
3449             pw.println("cmd shortcut reset-all-throttling");
3450             pw.println("    Reset the throttling state for all users");
3451             pw.println();
3452             pw.println("cmd shortcut override-config CONFIG");
3453             pw.println("    Override the configuration for testing (will last until reboot)");
3454             pw.println();
3455             pw.println("cmd shortcut reset-config");
3456             pw.println("    Reset the configuration set with \"update-config\"");
3457             pw.println();
3458             pw.println("cmd shortcut clear-default-launcher [--user USER_ID]");
3459             pw.println("    Clear the cached default launcher");
3460             pw.println();
3461             pw.println("cmd shortcut get-default-launcher [--user USER_ID]");
3462             pw.println("    Show the default launcher");
3463             pw.println();
3464             pw.println("cmd shortcut unload-user [--user USER_ID]");
3465             pw.println("    Unload a user from the memory");
3466             pw.println("    (This should not affect any observable behavior)");
3467             pw.println();
3468             pw.println("cmd shortcut clear-shortcuts [--user USER_ID] PACKAGE");
3469             pw.println("    Remove all shortcuts from a package, including pinned shortcuts");
3470             pw.println();
3471         }
3472
3473         private void handleResetThrottling() throws CommandException {
3474             synchronized (mLock) {
3475                 parseOptionsLocked(/* takeUser =*/ true);
3476
3477                 Slog.i(TAG, "cmd: handleResetThrottling: user=" + mUserId);
3478
3479                 resetThrottlingInner(mUserId);
3480             }
3481         }
3482
3483         private void handleResetAllThrottling() {
3484             Slog.i(TAG, "cmd: handleResetAllThrottling");
3485
3486             resetAllThrottlingInner();
3487         }
3488
3489         private void handleOverrideConfig() throws CommandException {
3490             final String config = getNextArgRequired();
3491
3492             Slog.i(TAG, "cmd: handleOverrideConfig: " + config);
3493
3494             synchronized (mLock) {
3495                 if (!updateConfigurationLocked(config)) {
3496                     throw new CommandException("override-config failed.  See logcat for details.");
3497                 }
3498             }
3499         }
3500
3501         private void handleResetConfig() {
3502             Slog.i(TAG, "cmd: handleResetConfig");
3503
3504             synchronized (mLock) {
3505                 loadConfigurationLocked();
3506             }
3507         }
3508
3509         private void clearLauncher() {
3510             synchronized (mLock) {
3511                 getUserShortcutsLocked(mUserId).forceClearLauncher();
3512             }
3513         }
3514
3515         private void showLauncher() {
3516             synchronized (mLock) {
3517                 // This ensures to set the cached launcher.  Package name doesn't matter.
3518                 hasShortcutHostPermissionInner("-", mUserId);
3519
3520                 getOutPrintWriter().println("Launcher: "
3521                         + getUserShortcutsLocked(mUserId).getLastKnownLauncher());
3522             }
3523         }
3524
3525         private void handleClearDefaultLauncher() throws CommandException {
3526             synchronized (mLock) {
3527                 parseOptionsLocked(/* takeUser =*/ true);
3528
3529                 clearLauncher();
3530             }
3531         }
3532
3533         private void handleGetDefaultLauncher() throws CommandException {
3534             synchronized (mLock) {
3535                 parseOptionsLocked(/* takeUser =*/ true);
3536
3537                 clearLauncher();
3538                 showLauncher();
3539             }
3540         }
3541
3542         private void handleUnloadUser() throws CommandException {
3543             synchronized (mLock) {
3544                 parseOptionsLocked(/* takeUser =*/ true);
3545
3546                 Slog.i(TAG, "cmd: handleUnloadUser: user=" + mUserId);
3547
3548                 ShortcutService.this.handleCleanupUser(mUserId);
3549             }
3550         }
3551
3552         private void handleClearShortcuts() throws CommandException {
3553             synchronized (mLock) {
3554                 parseOptionsLocked(/* takeUser =*/ true);
3555                 final String packageName = getNextArgRequired();
3556
3557                 Slog.i(TAG, "cmd: handleClearShortcuts: user" + mUserId + ", " + packageName);
3558
3559                 ShortcutService.this.cleanUpPackageForAllLoadedUsers(packageName, mUserId,
3560                         /* appStillExists = */ true);
3561             }
3562         }
3563
3564         private void handleVerifyStates() throws CommandException {
3565             try {
3566                 verifyStatesForce(); // This will throw when there's an issue.
3567             } catch (Throwable th) {
3568                 throw new CommandException(th.getMessage() + "\n" + Log.getStackTraceString(th));
3569             }
3570         }
3571     }
3572
3573     // === Unit test support ===
3574
3575     // Injection point.
3576     @VisibleForTesting
3577     long injectCurrentTimeMillis() {
3578         return System.currentTimeMillis();
3579     }
3580
3581     @VisibleForTesting
3582     long injectElapsedRealtime() {
3583         return SystemClock.elapsedRealtime();
3584     }
3585
3586     // Injection point.
3587     @VisibleForTesting
3588     int injectBinderCallingUid() {
3589         return getCallingUid();
3590     }
3591
3592     private int getCallingUserId() {
3593         return UserHandle.getUserId(injectBinderCallingUid());
3594     }
3595
3596     // Injection point.
3597     @VisibleForTesting
3598     long injectClearCallingIdentity() {
3599         return Binder.clearCallingIdentity();
3600     }
3601
3602     // Injection point.
3603     @VisibleForTesting
3604     void injectRestoreCallingIdentity(long token) {
3605         Binder.restoreCallingIdentity(token);
3606     }
3607
3608     // Injection point.
3609     @VisibleForTesting
3610     String injectBuildFingerprint() {
3611         return Build.FINGERPRINT;
3612     }
3613
3614     final void wtf(String message) {
3615         wtf(message, /* exception= */ null);
3616     }
3617
3618     // Injection point.
3619     void wtf(String message, Throwable e) {
3620         if (e == null) {
3621             e = new RuntimeException("Stacktrace");
3622         }
3623         synchronized (mLock) {
3624             mWtfCount++;
3625             mLastWtfStacktrace = new Exception("Last failure was logged here:");
3626         }
3627         Slog.wtf(TAG, message, e);
3628     }
3629
3630     @VisibleForTesting
3631     File injectSystemDataPath() {
3632         return Environment.getDataSystemDirectory();
3633     }
3634
3635     @VisibleForTesting
3636     File injectUserDataPath(@UserIdInt int userId) {
3637         return new File(Environment.getDataSystemCeDirectory(userId), DIRECTORY_PER_USER);
3638     }
3639
3640     @VisibleForTesting
3641     boolean injectIsLowRamDevice() {
3642         return ActivityManager.isLowRamDeviceStatic();
3643     }
3644
3645     @VisibleForTesting
3646     void injectRegisterUidObserver(IUidObserver observer, int which) {
3647         try {
3648             ActivityManagerNative.getDefault().registerUidObserver(observer, which);
3649         } catch (RemoteException shouldntHappen) {
3650         }
3651     }
3652
3653     File getUserBitmapFilePath(@UserIdInt int userId) {
3654         return new File(injectUserDataPath(userId), DIRECTORY_BITMAPS);
3655     }
3656
3657     @VisibleForTesting
3658     SparseArray<ShortcutUser> getShortcutsForTest() {
3659         return mUsers;
3660     }
3661
3662     @VisibleForTesting
3663     int getMaxShortcutsForTest() {
3664         return mMaxShortcuts;
3665     }
3666
3667     @VisibleForTesting
3668     int getMaxUpdatesPerIntervalForTest() {
3669         return mMaxUpdatesPerInterval;
3670     }
3671
3672     @VisibleForTesting
3673     long getResetIntervalForTest() {
3674         return mResetInterval;
3675     }
3676
3677     @VisibleForTesting
3678     int getMaxIconDimensionForTest() {
3679         return mMaxIconDimension;
3680     }
3681
3682     @VisibleForTesting
3683     CompressFormat getIconPersistFormatForTest() {
3684         return mIconPersistFormat;
3685     }
3686
3687     @VisibleForTesting
3688     int getIconPersistQualityForTest() {
3689         return mIconPersistQuality;
3690     }
3691
3692     @VisibleForTesting
3693     ShortcutPackage getPackageShortcutForTest(String packageName, int userId) {
3694         synchronized (mLock) {
3695             final ShortcutUser user = mUsers.get(userId);
3696             if (user == null) return null;
3697
3698             return user.getAllPackagesForTest().get(packageName);
3699         }
3700     }
3701
3702     @VisibleForTesting
3703     ShortcutInfo getPackageShortcutForTest(String packageName, String shortcutId, int userId) {
3704         synchronized (mLock) {
3705             final ShortcutPackage pkg = getPackageShortcutForTest(packageName, userId);
3706             if (pkg == null) return null;
3707
3708             return pkg.findShortcutById(shortcutId);
3709         }
3710     }
3711
3712     /**
3713      * Control whether {@link #verifyStates} should be performed.  We always perform it during unit
3714      * tests.
3715      */
3716     @VisibleForTesting
3717     boolean injectShouldPerformVerification() {
3718         return DEBUG;
3719     }
3720
3721     /**
3722      * Check various internal states and throws if there's any inconsistency.
3723      * This is normally only enabled during unit tests.
3724      */
3725     final void verifyStates() {
3726         if (injectShouldPerformVerification()) {
3727             verifyStatesInner();
3728         }
3729     }
3730
3731     private final void verifyStatesForce() {
3732         verifyStatesInner();
3733     }
3734
3735     private void verifyStatesInner() {
3736         synchronized (mLock) {
3737             forEachLoadedUserLocked(u -> u.forAllPackageItems(ShortcutPackageItem::verifyStates));
3738         }
3739     }
3740 }