packages/SettingsLib/src/com/android/settingslib/applications/ApplicationsState.java

   1 /*
   2  * Copyright (C) 2015 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package com.android.settingslib.applications;
  18
  19 import android.app.ActivityManager;
  20 import android.app.AppGlobals;
  21 import android.app.Application;
  22 import android.app.usage.StorageStats;
  23 import android.app.usage.StorageStatsManager;
  24 import android.content.BroadcastReceiver;
  25 import android.content.Context;
  26 import android.content.Intent;
  27 import android.content.IntentFilter;
  28 import android.content.pm.ApplicationInfo;
  29 import android.content.pm.IPackageManager;
  30 import android.content.pm.IPackageStatsObserver;
  31 import android.content.pm.PackageManager;
  32 import android.content.pm.PackageManager.NameNotFoundException;
  33 import android.content.pm.PackageStats;
  34 import android.content.pm.ParceledListSlice;
  35 import android.content.pm.ResolveInfo;
  36 import android.content.pm.UserInfo;
  37 import android.graphics.drawable.Drawable;
  38 import android.net.Uri;
  39 import android.os.Handler;
  40 import android.os.HandlerThread;
  41 import android.os.Looper;
  42 import android.os.Message;
  43 import android.os.Process;
  44 import android.os.RemoteException;
  45 import android.os.SystemClock;
  46 import android.os.UserHandle;
  47 import android.os.UserManager;
  48 import android.text.format.Formatter;
  49 import android.util.IconDrawableFactory;
  50 import android.util.Log;
  51 import android.util.SparseArray;
  52
  53 import com.android.internal.R;
  54 import com.android.internal.util.ArrayUtils;
  55
  56 import java.io.File;
  57 import java.io.IOException;
  58 import java.text.Collator;
  59 import java.text.Normalizer;
  60 import java.text.Normalizer.Form;
  61 import java.util.ArrayList;
  62 import java.util.Collections;
  63 import java.util.Comparator;
  64 import java.util.HashMap;
  65 import java.util.List;
  66 import java.util.Objects;
  67 import java.util.UUID;
  68 import java.util.regex.Pattern;
  69
  70 /**
  71  * Keeps track of information about all installed applications, lazy-loading
  72  * as needed.
  73  */
  74 public class ApplicationsState {
  75     static final String TAG = "ApplicationsState";
  76     static final boolean DEBUG = false;
  77     static final boolean DEBUG_LOCKING = false;
  78
  79     public static final int SIZE_UNKNOWN = -1;
  80     public static final int SIZE_INVALID = -2;
  81
  82     static final Pattern REMOVE_DIACRITICALS_PATTERN
  83             = Pattern.compile("\\p{InCombiningDiacriticalMarks}+");
  84
  85     static final Object sLock = new Object();
  86     static ApplicationsState sInstance;
  87
  88     public static ApplicationsState getInstance(Application app) {
  89         synchronized (sLock) {
  90             if (sInstance == null) {
  91                 sInstance = new ApplicationsState(app);
  92             }
  93             return sInstance;
  94         }
  95     }
  96
  97     final Context mContext;
  98     final PackageManager mPm;
  99     final IconDrawableFactory mDrawableFactory;
 100     final IPackageManager mIpm;
 101     final UserManager mUm;
 102     final StorageStatsManager mStats;
 103     final int mAdminRetrieveFlags;
 104     final int mRetrieveFlags;
 105     PackageIntentReceiver mPackageIntentReceiver;
 106
 107     boolean mResumed;
 108     boolean mHaveDisabledApps;
 109     boolean mHaveInstantApps;
 110
 111     // Information about all applications.  Synchronize on mEntriesMap
 112     // to protect access to these.
 113     final ArrayList<Session> mSessions = new ArrayList<Session>();
 114     final ArrayList<Session> mRebuildingSessions = new ArrayList<Session>();
 115     final InterestingConfigChanges mInterestingConfigChanges = new InterestingConfigChanges();
 116     // Map: userid => (Map: package name => AppEntry)
 117     final SparseArray<HashMap<String, AppEntry>> mEntriesMap =
 118             new SparseArray<HashMap<String, AppEntry>>();
 119     final ArrayList<AppEntry> mAppEntries = new ArrayList<AppEntry>();
 120     List<ApplicationInfo> mApplications = new ArrayList<ApplicationInfo>();
 121     long mCurId = 1;
 122     UUID mCurComputingSizeUuid;
 123     String mCurComputingSizePkg;
 124     int mCurComputingSizeUserId;
 125     boolean mSessionsChanged;
 126
 127     // Temporary for dispatching session callbacks.  Only touched by main thread.
 128     final ArrayList<Session> mActiveSessions = new ArrayList<Session>();
 129
 130     final HandlerThread mThread;
 131     final BackgroundHandler mBackgroundHandler;
 132     final MainHandler mMainHandler = new MainHandler(Looper.getMainLooper());
 133
 134     private ApplicationsState(Application app) {
 135         mContext = app;
 136         mPm = mContext.getPackageManager();
 137         mDrawableFactory = IconDrawableFactory.newInstance(mContext);
 138         mIpm = AppGlobals.getPackageManager();
 139         mUm = mContext.getSystemService(UserManager.class);
 140         mStats = mContext.getSystemService(StorageStatsManager.class);
 141         for (int userId : mUm.getProfileIdsWithDisabled(UserHandle.myUserId())) {
 142             mEntriesMap.put(userId, new HashMap<String, AppEntry>());
 143         }
 144         mThread = new HandlerThread("ApplicationsState.Loader",
 145                 Process.THREAD_PRIORITY_BACKGROUND);
 146         mThread.start();
 147         mBackgroundHandler = new BackgroundHandler(mThread.getLooper());
 148
 149         // Only the owner can see all apps.
 150         mAdminRetrieveFlags = PackageManager.MATCH_ANY_USER |
 151                 PackageManager.MATCH_DISABLED_COMPONENTS |
 152                 PackageManager.MATCH_DISABLED_UNTIL_USED_COMPONENTS;
 153         mRetrieveFlags = PackageManager.MATCH_DISABLED_COMPONENTS |
 154                 PackageManager.MATCH_DISABLED_UNTIL_USED_COMPONENTS;
 155
 156         /**
 157          * This is a trick to prevent the foreground thread from being delayed.
 158          * The problem is that Dalvik monitors are initially spin locks, to keep
 159          * them lightweight.  This leads to unfair contention -- Even though the
 160          * background thread only holds the lock for a short amount of time, if
 161          * it keeps running and locking again it can prevent the main thread from
 162          * acquiring its lock for a long time...  sometimes even > 5 seconds
 163          * (leading to an ANR).
 164          *
 165          * Dalvik will promote a monitor to a "real" lock if it detects enough
 166          * contention on it.  It doesn't figure this out fast enough for us
 167          * here, though, so this little trick will force it to turn into a real
 168          * lock immediately.
 169          */
 170         synchronized (mEntriesMap) {
 171             try {
 172                 mEntriesMap.wait(1);
 173             } catch (InterruptedException e) {
 174             }
 175         }
 176     }
 177
 178     public Looper getBackgroundLooper() {
 179         return mThread.getLooper();
 180     }
 181
 182     public Session newSession(Callbacks callbacks) {
 183         Session s = new Session(callbacks);
 184         synchronized (mEntriesMap) {
 185             mSessions.add(s);
 186         }
 187         return s;
 188     }
 189
 190     void doResumeIfNeededLocked() {
 191         if (mResumed) {
 192             return;
 193         }
 194         mResumed = true;
 195         if (mPackageIntentReceiver == null) {
 196             mPackageIntentReceiver = new PackageIntentReceiver();
 197             mPackageIntentReceiver.registerReceiver();
 198         }
 199         mApplications = new ArrayList<ApplicationInfo>();
 200         for (UserInfo user : mUm.getProfiles(UserHandle.myUserId())) {
 201             try {
 202                 // If this user is new, it needs a map created.
 203                 if (mEntriesMap.indexOfKey(user.id) < 0) {
 204                     mEntriesMap.put(user.id, new HashMap<String, AppEntry>());
 205                 }
 206                 @SuppressWarnings("unchecked")
 207                 ParceledListSlice<ApplicationInfo> list =
 208                         mIpm.getInstalledApplications(
 209                                 user.isAdmin() ? mAdminRetrieveFlags : mRetrieveFlags,
 210                                 user.id);
 211                 mApplications.addAll(list.getList());
 212             } catch (RemoteException e) {
 213             }
 214         }
 215
 216         if (mInterestingConfigChanges.applyNewConfig(mContext.getResources())) {
 217             // If an interesting part of the configuration has changed, we
 218             // should completely reload the app entries.
 219             clearEntries();
 220         } else {
 221             for (int i=0; i<mAppEntries.size(); i++) {
 222                 mAppEntries.get(i).sizeStale = true;
 223             }
 224         }
 225
 226         mHaveDisabledApps = false;
 227         mHaveInstantApps = false;
 228         for (int i=0; i<mApplications.size(); i++) {
 229             final ApplicationInfo info = mApplications.get(i);
 230             // Need to trim out any applications that are disabled by
 231             // something different than the user.
 232             if (!info.enabled) {
 233                 if (info.enabledSetting != PackageManager.COMPONENT_ENABLED_STATE_DISABLED_USER) {
 234                     mApplications.remove(i);
 235                     i--;
 236                     continue;
 237                 }
 238                 mHaveDisabledApps = true;
 239             }
 240             if (!mHaveInstantApps && AppUtils.isInstant(info)) {
 241                 mHaveInstantApps = true;
 242             }
 243
 244             int userId = UserHandle.getUserId(info.uid);
 245             final AppEntry entry = mEntriesMap.get(userId).get(info.packageName);
 246             if (entry != null) {
 247                 entry.info = info;
 248             }
 249         }
 250         if (mAppEntries.size() > mApplications.size()) {
 251             // There are less apps now, some must have been uninstalled.
 252             clearEntries();
 253         }
 254         mCurComputingSizePkg = null;
 255         if (!mBackgroundHandler.hasMessages(BackgroundHandler.MSG_LOAD_ENTRIES)) {
 256             mBackgroundHandler.sendEmptyMessage(BackgroundHandler.MSG_LOAD_ENTRIES);
 257         }
 258     }
 259
 260     private void clearEntries() {
 261         for (int i = 0; i < mEntriesMap.size(); i++) {
 262             mEntriesMap.valueAt(i).clear();
 263         }
 264         mAppEntries.clear();
 265     }
 266
 267     public boolean haveDisabledApps() {
 268         return mHaveDisabledApps;
 269     }
 270     public boolean haveInstantApps() {
 271         return mHaveInstantApps;
 272     }
 273
 274     void doPauseIfNeededLocked() {
 275         if (!mResumed) {
 276             return;
 277         }
 278         for (int i=0; i<mSessions.size(); i++) {
 279             if (mSessions.get(i).mResumed) {
 280                 return;
 281             }
 282         }
 283         doPauseLocked();
 284     }
 285
 286     void doPauseLocked() {
 287         mResumed = false;
 288         if (mPackageIntentReceiver != null) {
 289             mPackageIntentReceiver.unregisterReceiver();
 290             mPackageIntentReceiver = null;
 291         }
 292     }
 293
 294     public AppEntry getEntry(String packageName, int userId) {
 295         if (DEBUG_LOCKING) Log.v(TAG, "getEntry about to acquire lock...");
 296         synchronized (mEntriesMap) {
 297             AppEntry entry = mEntriesMap.get(userId).get(packageName);
 298             if (entry == null) {
 299                 ApplicationInfo info = getAppInfoLocked(packageName, userId);
 300                 if (info == null) {
 301                     try {
 302                         info = mIpm.getApplicationInfo(packageName, 0, userId);
 303                     } catch (RemoteException e) {
 304                         Log.w(TAG, "getEntry couldn't reach PackageManager", e);
 305                         return null;
 306                     }
 307                 }
 308                 if (info != null) {
 309                     entry = getEntryLocked(info);
 310                 }
 311             }
 312             if (DEBUG_LOCKING) Log.v(TAG, "...getEntry releasing lock");
 313             return entry;
 314         }
 315     }
 316
 317     private ApplicationInfo getAppInfoLocked(String pkg, int userId) {
 318         for (int i = 0; i < mApplications.size(); i++) {
 319             ApplicationInfo info = mApplications.get(i);
 320             if (pkg.equals(info.packageName)
 321                     && userId == UserHandle.getUserId(info.uid)) {
 322                 return info;
 323             }
 324         }
 325         return null;
 326     }
 327
 328     public void ensureIcon(AppEntry entry) {
 329         if (entry.icon != null) {
 330             return;
 331         }
 332         synchronized (entry) {
 333             entry.ensureIconLocked(mContext, mDrawableFactory);
 334         }
 335     }
 336
 337     public void requestSize(String packageName, int userId) {
 338         if (DEBUG_LOCKING) Log.v(TAG, "requestSize about to acquire lock...");
 339         synchronized (mEntriesMap) {
 340             AppEntry entry = mEntriesMap.get(userId).get(packageName);
 341             if (entry != null && (entry.info.flags & ApplicationInfo.FLAG_INSTALLED) != 0) {
 342                 mBackgroundHandler.post(() -> {
 343                     try {
 344                         final StorageStats stats = mStats.queryStatsForPackage(
 345                                 entry.info.storageUuid, packageName, UserHandle.of(userId));
 346                         final PackageStats legacy = new PackageStats(packageName, userId);
 347                         legacy.codeSize = stats.getCodeBytes();
 348                         legacy.dataSize = stats.getDataBytes();
 349                         legacy.cacheSize = stats.getCacheBytes();
 350                         try {
 351                             mBackgroundHandler.mStatsObserver.onGetStatsCompleted(legacy, true);
 352                         } catch (RemoteException ignored) {
 353                         }
 354                     } catch (NameNotFoundException | IOException e) {
 355                         Log.w(TAG, "Failed to query stats: " + e);
 356                         try {
 357                             mBackgroundHandler.mStatsObserver.onGetStatsCompleted(null, false);
 358                         } catch (RemoteException ignored) {
 359                         }
 360                     }
 361                 });
 362             }
 363             if (DEBUG_LOCKING) Log.v(TAG, "...requestSize releasing lock");
 364         }
 365     }
 366
 367     long sumCacheSizes() {
 368         long sum = 0;
 369         if (DEBUG_LOCKING) Log.v(TAG, "sumCacheSizes about to acquire lock...");
 370         synchronized (mEntriesMap) {
 371             if (DEBUG_LOCKING) Log.v(TAG, "-> sumCacheSizes now has lock");
 372             for (int i=mAppEntries.size()-1; i>=0; i--) {
 373                 sum += mAppEntries.get(i).cacheSize;
 374             }
 375             if (DEBUG_LOCKING) Log.v(TAG, "...sumCacheSizes releasing lock");
 376         }
 377         return sum;
 378     }
 379
 380     int indexOfApplicationInfoLocked(String pkgName, int userId) {
 381         for (int i=mApplications.size()-1; i>=0; i--) {
 382             ApplicationInfo appInfo = mApplications.get(i);
 383             if (appInfo.packageName.equals(pkgName)
 384                     && UserHandle.getUserId(appInfo.uid) == userId) {
 385                 return i;
 386             }
 387         }
 388         return -1;
 389     }
 390
 391     void addPackage(String pkgName, int userId) {
 392         try {
 393             synchronized (mEntriesMap) {
 394                 if (DEBUG_LOCKING) Log.v(TAG, "addPackage acquired lock");
 395                 if (DEBUG) Log.i(TAG, "Adding package " + pkgName);
 396                 if (!mResumed) {
 397                     // If we are not resumed, we will do a full query the
 398                     // next time we resume, so there is no reason to do work
 399                     // here.
 400                     if (DEBUG_LOCKING) Log.v(TAG, "addPackage release lock: not resumed");
 401                     return;
 402                 }
 403                 if (indexOfApplicationInfoLocked(pkgName, userId) >= 0) {
 404                     if (DEBUG) Log.i(TAG, "Package already exists!");
 405                     if (DEBUG_LOCKING) Log.v(TAG, "addPackage release lock: already exists");
 406                     return;
 407                 }
 408                 ApplicationInfo info = mIpm.getApplicationInfo(pkgName,
 409                         mUm.isUserAdmin(userId) ? mAdminRetrieveFlags : mRetrieveFlags,
 410                         userId);
 411                 if (info == null) {
 412                     return;
 413                 }
 414                 if (!info.enabled) {
 415                     if (info.enabledSetting
 416                             != PackageManager.COMPONENT_ENABLED_STATE_DISABLED_USER) {
 417                         return;
 418                     }
 419                     mHaveDisabledApps = true;
 420                 }
 421                 if (AppUtils.isInstant(info)) {
 422                     mHaveInstantApps = true;
 423                 }
 424                 mApplications.add(info);
 425                 if (!mBackgroundHandler.hasMessages(BackgroundHandler.MSG_LOAD_ENTRIES)) {
 426                     mBackgroundHandler.sendEmptyMessage(BackgroundHandler.MSG_LOAD_ENTRIES);
 427                 }
 428                 if (!mMainHandler.hasMessages(MainHandler.MSG_PACKAGE_LIST_CHANGED)) {
 429                     mMainHandler.sendEmptyMessage(MainHandler.MSG_PACKAGE_LIST_CHANGED);
 430                 }
 431                 if (DEBUG_LOCKING) Log.v(TAG, "addPackage releasing lock");
 432             }
 433         } catch (RemoteException e) {
 434         }
 435     }
 436
 437     public void removePackage(String pkgName, int userId) {
 438         synchronized (mEntriesMap) {
 439             if (DEBUG_LOCKING) Log.v(TAG, "removePackage acquired lock");
 440             int idx = indexOfApplicationInfoLocked(pkgName, userId);
 441             if (DEBUG) Log.i(TAG, "removePackage: " + pkgName + " @ " + idx);
 442             if (idx >= 0) {
 443                 AppEntry entry = mEntriesMap.get(userId).get(pkgName);
 444                 if (DEBUG) Log.i(TAG, "removePackage: " + entry);
 445                 if (entry != null) {
 446                     mEntriesMap.get(userId).remove(pkgName);
 447                     mAppEntries.remove(entry);
 448                 }
 449                 ApplicationInfo info = mApplications.get(idx);
 450                 mApplications.remove(idx);
 451                 if (!info.enabled) {
 452                     mHaveDisabledApps = false;
 453                     for (ApplicationInfo otherInfo : mApplications) {
 454                         if (!otherInfo.enabled) {
 455                             mHaveDisabledApps = true;
 456                             break;
 457                         }
 458                     }
 459                 }
 460                 if (AppUtils.isInstant(info)) {
 461                     mHaveInstantApps = false;
 462                     for (ApplicationInfo otherInfo : mApplications) {
 463                         if (AppUtils.isInstant(otherInfo)) {
 464                             mHaveInstantApps = true;
 465                             break;
 466                         }
 467                     }
 468                 }
 469                 if (!mMainHandler.hasMessages(MainHandler.MSG_PACKAGE_LIST_CHANGED)) {
 470                     mMainHandler.sendEmptyMessage(MainHandler.MSG_PACKAGE_LIST_CHANGED);
 471                 }
 472             }
 473             if (DEBUG_LOCKING) Log.v(TAG, "removePackage releasing lock");
 474         }
 475     }
 476
 477     public void invalidatePackage(String pkgName, int userId) {
 478         removePackage(pkgName, userId);
 479         addPackage(pkgName, userId);
 480     }
 481
 482     private void addUser(int userId) {
 483         final int profileIds[] = mUm.getProfileIdsWithDisabled(UserHandle.myUserId());
 484         if (ArrayUtils.contains(profileIds, userId)) {
 485             synchronized (mEntriesMap) {
 486                 mEntriesMap.put(userId, new HashMap<String, AppEntry>());
 487                 if (mResumed) {
 488                     // If resumed, Manually pause, then cause a resume to repopulate the app list.
 489                     // This is the simplest way to reload the packages so that the new user
 490                     // is included.  Otherwise the list will be repopulated on next resume.
 491                     doPauseLocked();
 492                     doResumeIfNeededLocked();
 493                 }
 494                 if (!mMainHandler.hasMessages(MainHandler.MSG_PACKAGE_LIST_CHANGED)) {
 495                     mMainHandler.sendEmptyMessage(MainHandler.MSG_PACKAGE_LIST_CHANGED);
 496                 }
 497             }
 498         }
 499     }
 500
 501     private void removeUser(int userId) {
 502         synchronized (mEntriesMap) {
 503             HashMap<String, AppEntry> userMap = mEntriesMap.get(userId);
 504             if (userMap != null) {
 505                 for (AppEntry appEntry : userMap.values()) {
 506                     mAppEntries.remove(appEntry);
 507                     mApplications.remove(appEntry.info);
 508                 }
 509                 mEntriesMap.remove(userId);
 510                 if (!mMainHandler.hasMessages(MainHandler.MSG_PACKAGE_LIST_CHANGED)) {
 511                     mMainHandler.sendEmptyMessage(MainHandler.MSG_PACKAGE_LIST_CHANGED);
 512                 }
 513             }
 514         }
 515     }
 516
 517     private AppEntry getEntryLocked(ApplicationInfo info) {
 518         int userId = UserHandle.getUserId(info.uid);
 519         AppEntry entry = mEntriesMap.get(userId).get(info.packageName);
 520         if (DEBUG) Log.i(TAG, "Looking up entry of pkg " + info.packageName + ": " + entry);
 521         if (entry == null) {
 522             if (DEBUG) Log.i(TAG, "Creating AppEntry for " + info.packageName);
 523             entry = new AppEntry(mContext, info, mCurId++);
 524             mEntriesMap.get(userId).put(info.packageName, entry);
 525             mAppEntries.add(entry);
 526         } else if (entry.info != info) {
 527             entry.info = info;
 528         }
 529         return entry;
 530     }
 531
 532     // --------------------------------------------------------------
 533
 534     private long getTotalInternalSize(PackageStats ps) {
 535         if (ps != null) {
 536             return ps.codeSize + ps.dataSize;
 537         }
 538         return SIZE_INVALID;
 539     }
 540
 541     private long getTotalExternalSize(PackageStats ps) {
 542         if (ps != null) {
 543             // We also include the cache size here because for non-emulated
 544             // we don't automtically clean cache files.
 545             return ps.externalCodeSize + ps.externalDataSize
 546                     + ps.externalCacheSize
 547                     + ps.externalMediaSize + ps.externalObbSize;
 548         }
 549         return SIZE_INVALID;
 550     }
 551
 552     private String getSizeStr(long size) {
 553         if (size >= 0) {
 554             return Formatter.formatFileSize(mContext, size);
 555         }
 556         return null;
 557     }
 558
 559     void rebuildActiveSessions() {
 560         synchronized (mEntriesMap) {
 561             if (!mSessionsChanged) {
 562                 return;
 563             }
 564             mActiveSessions.clear();
 565             for (int i=0; i<mSessions.size(); i++) {
 566                 Session s = mSessions.get(i);
 567                 if (s.mResumed) {
 568                     mActiveSessions.add(s);
 569                 }
 570             }
 571         }
 572     }
 573
 574     public static String normalize(String str) {
 575         String tmp = Normalizer.normalize(str, Form.NFD);
 576         return REMOVE_DIACRITICALS_PATTERN.matcher(tmp)
 577                 .replaceAll("").toLowerCase();
 578     }
 579
 580     public class Session {
 581         final Callbacks mCallbacks;
 582         boolean mResumed;
 583
 584         // Rebuilding of app list.  Synchronized on mRebuildSync.
 585         final Object mRebuildSync = new Object();
 586         boolean mRebuildRequested;
 587         boolean mRebuildAsync;
 588         AppFilter mRebuildFilter;
 589         Comparator<AppEntry> mRebuildComparator;
 590         ArrayList<AppEntry> mRebuildResult;
 591         ArrayList<AppEntry> mLastAppList;
 592         boolean mRebuildForeground;
 593
 594         Session(Callbacks callbacks) {
 595             mCallbacks = callbacks;
 596         }
 597
 598         public void resume() {
 599             if (DEBUG_LOCKING) Log.v(TAG, "resume about to acquire lock...");
 600             synchronized (mEntriesMap) {
 601                 if (!mResumed) {
 602                     mResumed = true;
 603                     mSessionsChanged = true;
 604                     doResumeIfNeededLocked();
 605                 }
 606             }
 607             if (DEBUG_LOCKING) Log.v(TAG, "...resume releasing lock");
 608         }
 609
 610         public void pause() {
 611             if (DEBUG_LOCKING) Log.v(TAG, "pause about to acquire lock...");
 612             synchronized (mEntriesMap) {
 613                 if (mResumed) {
 614                     mResumed = false;
 615                     mSessionsChanged = true;
 616                     mBackgroundHandler.removeMessages(BackgroundHandler.MSG_REBUILD_LIST, this);
 617                     doPauseIfNeededLocked();
 618                 }
 619                 if (DEBUG_LOCKING) Log.v(TAG, "...pause releasing lock");
 620             }
 621         }
 622
 623         public ArrayList<AppEntry> getAllApps() {
 624             synchronized (mEntriesMap) {
 625                 return new ArrayList<>(mAppEntries);
 626             }
 627         }
 628
 629         // Creates a new list of app entries with the given filter and comparator.
 630         public ArrayList<AppEntry> rebuild(AppFilter filter, Comparator<AppEntry> comparator) {
 631             return rebuild(filter, comparator, true);
 632         }
 633
 634         public ArrayList<AppEntry> rebuild(AppFilter filter, Comparator<AppEntry> comparator,
 635                 boolean foreground) {
 636             synchronized (mRebuildSync) {
 637                 synchronized (mRebuildingSessions) {
 638                     mRebuildingSessions.add(this);
 639                     mRebuildRequested = true;
 640                     mRebuildAsync = true;
 641                     mRebuildFilter = filter;
 642                     mRebuildComparator = comparator;
 643                     mRebuildForeground = foreground;
 644                     mRebuildResult = null;
 645                     if (!mBackgroundHandler.hasMessages(BackgroundHandler.MSG_REBUILD_LIST)) {
 646                         Message msg = mBackgroundHandler.obtainMessage(
 647                                 BackgroundHandler.MSG_REBUILD_LIST);
 648                         mBackgroundHandler.sendMessage(msg);
 649                     }
 650                 }
 651
 652                 return null;
 653             }
 654         }
 655
 656         void handleRebuildList() {
 657             AppFilter filter;
 658             Comparator<AppEntry> comparator;
 659             synchronized (mRebuildSync) {
 660                 if (!mRebuildRequested) {
 661                     return;
 662                 }
 663
 664                 filter = mRebuildFilter;
 665                 comparator = mRebuildComparator;
 666                 mRebuildRequested = false;
 667                 mRebuildFilter = null;
 668                 mRebuildComparator = null;
 669                 if (mRebuildForeground) {
 670                     Process.setThreadPriority(Process.THREAD_PRIORITY_FOREGROUND);
 671                     mRebuildForeground = false;
 672                 }
 673             }
 674
 675             if (filter != null) {
 676                 filter.init(mContext);
 677             }
 678
 679             List<AppEntry> apps;
 680             synchronized (mEntriesMap) {
 681                 apps = new ArrayList<>(mAppEntries);
 682             }
 683
 684             ArrayList<AppEntry> filteredApps = new ArrayList<AppEntry>();
 685             if (DEBUG) Log.i(TAG, "Rebuilding...");
 686             for (int i=0; i<apps.size(); i++) {
 687                 AppEntry entry = apps.get(i);
 688                 if (entry != null && (filter == null || filter.filterApp(entry))) {
 689                     synchronized (mEntriesMap) {
 690                         if (DEBUG_LOCKING) Log.v(TAG, "rebuild acquired lock");
 691                         if (comparator != null) {
 692                             // Only need the label if we are going to be sorting.
 693                             entry.ensureLabel(mContext);
 694                         }
 695                         if (DEBUG) Log.i(TAG, "Using " + entry.info.packageName + ": " + entry);
 696                         filteredApps.add(entry);
 697                         if (DEBUG_LOCKING) Log.v(TAG, "rebuild releasing lock");
 698                     }
 699                 }
 700             }
 701
 702             if (comparator != null) {
 703                 synchronized (mEntriesMap) {
 704                     // Locking to ensure that the background handler does not mutate
 705                     // the size of AppEntries used for ordering while sorting.
 706                     Collections.sort(filteredApps, comparator);
 707                 }
 708             }
 709
 710             synchronized (mRebuildSync) {
 711                 if (!mRebuildRequested) {
 712                     mLastAppList = filteredApps;
 713                     if (!mRebuildAsync) {
 714                         mRebuildResult = filteredApps;
 715                         mRebuildSync.notifyAll();
 716                     } else {
 717                         if (!mMainHandler.hasMessages(MainHandler.MSG_REBUILD_COMPLETE, this)) {
 718                             Message msg = mMainHandler.obtainMessage(
 719                                     MainHandler.MSG_REBUILD_COMPLETE, this);
 720                             mMainHandler.sendMessage(msg);
 721                         }
 722                     }
 723                 }
 724             }
 725
 726             Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
 727         }
 728
 729         public void release() {
 730             pause();
 731             synchronized (mEntriesMap) {
 732                 mSessions.remove(this);
 733             }
 734         }
 735     }
 736
 737     class MainHandler extends Handler {
 738         static final int MSG_REBUILD_COMPLETE = 1;
 739         static final int MSG_PACKAGE_LIST_CHANGED = 2;
 740         static final int MSG_PACKAGE_ICON_CHANGED = 3;
 741         static final int MSG_PACKAGE_SIZE_CHANGED = 4;
 742         static final int MSG_ALL_SIZES_COMPUTED = 5;
 743         static final int MSG_RUNNING_STATE_CHANGED = 6;
 744         static final int MSG_LAUNCHER_INFO_CHANGED = 7;
 745         static final int MSG_LOAD_ENTRIES_COMPLETE = 8;
 746
 747         public MainHandler(Looper looper) {
 748             super(looper);
 749         }
 750
 751         @Override
 752         public void handleMessage(Message msg) {
 753             rebuildActiveSessions();
 754             switch (msg.what) {
 755                 case MSG_REBUILD_COMPLETE: {
 756                     Session s = (Session)msg.obj;
 757                     if (mActiveSessions.contains(s)) {
 758                         s.mCallbacks.onRebuildComplete(s.mLastAppList);
 759                     }
 760                 } break;
 761                 case MSG_PACKAGE_LIST_CHANGED: {
 762                     for (int i=0; i<mActiveSessions.size(); i++) {
 763                         mActiveSessions.get(i).mCallbacks.onPackageListChanged();
 764                     }
 765                 } break;
 766                 case MSG_PACKAGE_ICON_CHANGED: {
 767                     for (int i=0; i<mActiveSessions.size(); i++) {
 768                         mActiveSessions.get(i).mCallbacks.onPackageIconChanged();
 769                     }
 770                 } break;
 771                 case MSG_PACKAGE_SIZE_CHANGED: {
 772                     for (int i=0; i<mActiveSessions.size(); i++) {
 773                         mActiveSessions.get(i).mCallbacks.onPackageSizeChanged(
 774                                 (String)msg.obj);
 775                     }
 776                 } break;
 777                 case MSG_ALL_SIZES_COMPUTED: {
 778                     for (int i=0; i<mActiveSessions.size(); i++) {
 779                         mActiveSessions.get(i).mCallbacks.onAllSizesComputed();
 780                     }
 781                 } break;
 782                 case MSG_RUNNING_STATE_CHANGED: {
 783                     for (int i=0; i<mActiveSessions.size(); i++) {
 784                         mActiveSessions.get(i).mCallbacks.onRunningStateChanged(
 785                                 msg.arg1 != 0);
 786                     }
 787                 } break;
 788                 case MSG_LAUNCHER_INFO_CHANGED: {
 789                     for (int i=0; i<mActiveSessions.size(); i++) {
 790                         mActiveSessions.get(i).mCallbacks.onLauncherInfoChanged();
 791                     }
 792                 } break;
 793                 case MSG_LOAD_ENTRIES_COMPLETE: {
 794                     for (int i=0; i<mActiveSessions.size(); i++) {
 795                         mActiveSessions.get(i).mCallbacks.onLoadEntriesCompleted();
 796                     }
 797                 } break;
 798             }
 799         }
 800     }
 801
 802     private class BackgroundHandler extends Handler {
 803         static final int MSG_REBUILD_LIST = 1;
 804         static final int MSG_LOAD_ENTRIES = 2;
 805         static final int MSG_LOAD_ICONS = 3;
 806         static final int MSG_LOAD_SIZES = 4;
 807         static final int MSG_LOAD_LAUNCHER = 5;
 808         static final int MSG_LOAD_HOME_APP = 6;
 809
 810         boolean mRunning;
 811
 812         BackgroundHandler(Looper looper) {
 813             super(looper);
 814         }
 815
 816         @Override
 817         public void handleMessage(Message msg) {
 818             // Always try rebuilding list first thing, if needed.
 819             ArrayList<Session> rebuildingSessions = null;
 820             synchronized (mRebuildingSessions) {
 821                 if (mRebuildingSessions.size() > 0) {
 822                     rebuildingSessions = new ArrayList<Session>(mRebuildingSessions);
 823                     mRebuildingSessions.clear();
 824                 }
 825             }
 826             if (rebuildingSessions != null) {
 827                 for (int i=0; i<rebuildingSessions.size(); i++) {
 828                     rebuildingSessions.get(i).handleRebuildList();
 829                 }
 830             }
 831
 832             switch (msg.what) {
 833                 case MSG_REBUILD_LIST: {
 834                 } break;
 835                 case MSG_LOAD_ENTRIES: {
 836                     int numDone = 0;
 837                     synchronized (mEntriesMap) {
 838                         if (DEBUG_LOCKING) Log.v(TAG, "MSG_LOAD_ENTRIES acquired lock");
 839                         for (int i = 0; i < mApplications.size() && numDone < 6; i++) {
 840                             if (!mRunning) {
 841                                 mRunning = true;
 842                                 Message m = mMainHandler.obtainMessage(
 843                                         MainHandler.MSG_RUNNING_STATE_CHANGED, 1);
 844                                 mMainHandler.sendMessage(m);
 845                             }
 846                             ApplicationInfo info = mApplications.get(i);
 847                             int userId = UserHandle.getUserId(info.uid);
 848                             if (mEntriesMap.get(userId).get(info.packageName) == null) {
 849                                 numDone++;
 850                                 getEntryLocked(info);
 851                             }
 852                             if (userId != 0 && mEntriesMap.indexOfKey(0) >= 0) {
 853                                 // If this app is for a profile and we are on the owner, remove
 854                                 // the owner entry if it isn't installed.  This will prevent
 855                                 // duplicates of work only apps showing up as 'not installed
 856                                 // for this user'.
 857                                 // Note: This depends on us traversing the users in order, which
 858                                 // happens because of the way we generate the list in
 859                                 // doResumeIfNeededLocked.
 860                                 AppEntry entry = mEntriesMap.get(0).get(info.packageName);
 861                                 if (entry != null &&
 862                                         (entry.info.flags & ApplicationInfo.FLAG_INSTALLED) == 0) {
 863                                     mEntriesMap.get(0).remove(info.packageName);
 864                                     mAppEntries.remove(entry);
 865                                 }
 866                             }
 867                         }
 868                         if (DEBUG_LOCKING) Log.v(TAG, "MSG_LOAD_ENTRIES releasing lock");
 869                     }
 870
 871                     if (numDone >= 6) {
 872                         sendEmptyMessage(MSG_LOAD_ENTRIES);
 873                     } else {
 874                         if (!mMainHandler.hasMessages(MainHandler.MSG_LOAD_ENTRIES_COMPLETE)) {
 875                             mMainHandler.sendEmptyMessage(MainHandler.MSG_LOAD_ENTRIES_COMPLETE);
 876                         }
 877                         sendEmptyMessage(MSG_LOAD_HOME_APP);
 878                     }
 879                 } break;
 880                 case MSG_LOAD_HOME_APP: {
 881                     final List<ResolveInfo> homeActivities = new ArrayList<>();
 882                     mPm.getHomeActivities(homeActivities);
 883                     synchronized (mEntriesMap) {
 884                         final int entryCount = mEntriesMap.size();
 885                         for (int i = 0; i < entryCount; i++) {
 886                             if (DEBUG_LOCKING) Log.v(TAG, "MSG_LOAD_HOME_APP acquired lock");
 887                             final HashMap<String, AppEntry> userEntries = mEntriesMap.valueAt(i);
 888                             for (ResolveInfo activity : homeActivities) {
 889                                 String packageName = activity.activityInfo.packageName;
 890                                 AppEntry entry = userEntries.get(packageName);
 891                                 if (entry != null) {
 892                                     entry.isHomeApp = true;
 893                                 }
 894                             }
 895                             if (DEBUG_LOCKING) Log.v(TAG, "MSG_LOAD_HOME_APP releasing lock");
 896                         }
 897                     }
 898                     sendEmptyMessage(MSG_LOAD_LAUNCHER);
 899                 }
 900                 break;
 901                 case MSG_LOAD_LAUNCHER: {
 902                     Intent launchIntent = new Intent(Intent.ACTION_MAIN, null)
 903                             .addCategory(Intent.CATEGORY_LAUNCHER);
 904                     for (int i = 0; i < mEntriesMap.size(); i++) {
 905                         int userId = mEntriesMap.keyAt(i);
 906                         // If we do not specify MATCH_DIRECT_BOOT_AWARE or
 907                         // MATCH_DIRECT_BOOT_UNAWARE, system will derive and update the flags
 908                         // according to the user's lock state. When the user is locked, components
 909                         // with ComponentInfo#directBootAware == false will be filtered. We should
 910                         // explicitly include both direct boot aware and unaware components here.
 911                         List<ResolveInfo> intents = mPm.queryIntentActivitiesAsUser(
 912                                 launchIntent,
 913                                 PackageManager.MATCH_DISABLED_COMPONENTS
 914                                         | PackageManager.MATCH_DIRECT_BOOT_AWARE
 915                                         | PackageManager.MATCH_DIRECT_BOOT_UNAWARE,
 916                                 userId
 917                         );
 918                         synchronized (mEntriesMap) {
 919                             if (DEBUG_LOCKING) Log.v(TAG, "MSG_LOAD_LAUNCHER acquired lock");
 920                             HashMap<String, AppEntry> userEntries = mEntriesMap.valueAt(i);
 921                             final int N = intents.size();
 922                             for (int j = 0; j < N; j++) {
 923                                 String packageName = intents.get(j).activityInfo.packageName;
 924                                 AppEntry entry = userEntries.get(packageName);
 925                                 if (entry != null) {
 926                                     entry.hasLauncherEntry = true;
 927                                 } else {
 928                                     Log.w(TAG, "Cannot find pkg: " + packageName
 929                                             + " on user " + userId);
 930                                 }
 931                             }
 932                             if (DEBUG_LOCKING) Log.v(TAG, "MSG_LOAD_LAUNCHER releasing lock");
 933                         }
 934                     }
 935
 936                     if (!mMainHandler.hasMessages(MainHandler.MSG_LAUNCHER_INFO_CHANGED)) {
 937                         mMainHandler.sendEmptyMessage(MainHandler.MSG_LAUNCHER_INFO_CHANGED);
 938                     }
 939                     sendEmptyMessage(MSG_LOAD_ICONS);
 940                 } break;
 941                 case MSG_LOAD_ICONS: {
 942                     int numDone = 0;
 943                     synchronized (mEntriesMap) {
 944                         if (DEBUG_LOCKING) Log.v(TAG, "MSG_LOAD_ICONS acquired lock");
 945                         for (int i=0; i<mAppEntries.size() && numDone<2; i++) {
 946                             AppEntry entry = mAppEntries.get(i);
 947                             if (entry.icon == null || !entry.mounted) {
 948                                 synchronized (entry) {
 949                                     if (entry.ensureIconLocked(mContext, mDrawableFactory)) {
 950                                         if (!mRunning) {
 951                                             mRunning = true;
 952                                             Message m = mMainHandler.obtainMessage(
 953                                                     MainHandler.MSG_RUNNING_STATE_CHANGED, 1);
 954                                             mMainHandler.sendMessage(m);
 955                                         }
 956                                         numDone++;
 957                                     }
 958                                 }
 959                             }
 960                         }
 961                         if (DEBUG_LOCKING) Log.v(TAG, "MSG_LOAD_ICONS releasing lock");
 962                     }
 963                     if (numDone > 0) {
 964                         if (!mMainHandler.hasMessages(MainHandler.MSG_PACKAGE_ICON_CHANGED)) {
 965                             mMainHandler.sendEmptyMessage(MainHandler.MSG_PACKAGE_ICON_CHANGED);
 966                         }
 967                     }
 968                     if (numDone >= 2) {
 969                         sendEmptyMessage(MSG_LOAD_ICONS);
 970                     } else {
 971                         sendEmptyMessage(MSG_LOAD_SIZES);
 972                     }
 973                 } break;
 974                 case MSG_LOAD_SIZES: {
 975                     synchronized (mEntriesMap) {
 976                         if (DEBUG_LOCKING) Log.v(TAG, "MSG_LOAD_SIZES acquired lock");
 977                         if (mCurComputingSizePkg != null) {
 978                             if (DEBUG_LOCKING) Log.v(TAG, "MSG_LOAD_SIZES releasing: currently computing");
 979                             return;
 980                         }
 981
 982                         long now = SystemClock.uptimeMillis();
 983                         for (int i=0; i<mAppEntries.size(); i++) {
 984                             AppEntry entry = mAppEntries.get(i);
 985                             if ((entry.info.flags & ApplicationInfo.FLAG_INSTALLED) != 0
 986                                     && (entry.size == SIZE_UNKNOWN || entry.sizeStale)) {
 987                                 if (entry.sizeLoadStart == 0 ||
 988                                         (entry.sizeLoadStart < (now-20*1000))) {
 989                                     if (!mRunning) {
 990                                         mRunning = true;
 991                                         Message m = mMainHandler.obtainMessage(
 992                                                 MainHandler.MSG_RUNNING_STATE_CHANGED, 1);
 993                                         mMainHandler.sendMessage(m);
 994                                     }
 995                                     entry.sizeLoadStart = now;
 996                                     mCurComputingSizeUuid = entry.info.storageUuid;
 997                                     mCurComputingSizePkg = entry.info.packageName;
 998                                     mCurComputingSizeUserId = UserHandle.getUserId(entry.info.uid);
 999
1000                                     mBackgroundHandler.post(() -> {
1001                                         try {
1002                                             final StorageStats stats = mStats.queryStatsForPackage(
1003                                                     mCurComputingSizeUuid, mCurComputingSizePkg,
1004                                                     UserHandle.of(mCurComputingSizeUserId));
1005                                             final PackageStats legacy = new PackageStats(
1006                                                     mCurComputingSizePkg, mCurComputingSizeUserId);
1007                                             legacy.codeSize = stats.getCodeBytes();
1008                                             legacy.dataSize = stats.getDataBytes();
1009                                             legacy.cacheSize = stats.getCacheBytes();
1010                                             try {
1011                                                 mStatsObserver.onGetStatsCompleted(legacy, true);
1012                                             } catch (RemoteException ignored) {
1013                                             }
1014                                         } catch (NameNotFoundException | IOException e) {
1015                                             Log.w(TAG, "Failed to query stats: " + e);
1016                                             try {
1017                                                 mStatsObserver.onGetStatsCompleted(null, false);
1018                                             } catch (RemoteException ignored) {
1019                                             }
1020                                         }
1021
1022                                     });
1023                                 }
1024                                 if (DEBUG_LOCKING) Log.v(TAG, "MSG_LOAD_SIZES releasing: now computing");
1025                                 return;
1026                             }
1027                         }
1028                         if (!mMainHandler.hasMessages(MainHandler.MSG_ALL_SIZES_COMPUTED)) {
1029                             mMainHandler.sendEmptyMessage(MainHandler.MSG_ALL_SIZES_COMPUTED);
1030                             mRunning = false;
1031                             Message m = mMainHandler.obtainMessage(
1032                                     MainHandler.MSG_RUNNING_STATE_CHANGED, 0);
1033                             mMainHandler.sendMessage(m);
1034                         }
1035                         if (DEBUG_LOCKING) Log.v(TAG, "MSG_LOAD_SIZES releasing lock");
1036                     }
1037                 } break;
1038             }
1039         }
1040
1041         final IPackageStatsObserver.Stub mStatsObserver = new IPackageStatsObserver.Stub() {
1042             public void onGetStatsCompleted(PackageStats stats, boolean succeeded) {
1043                 if (!succeeded) {
1044                     // There is no meaningful information in stats if the call failed.
1045                     return;
1046                 }
1047
1048                 boolean sizeChanged = false;
1049                 synchronized (mEntriesMap) {
1050                     if (DEBUG_LOCKING) Log.v(TAG, "onGetStatsCompleted acquired lock");
1051                     HashMap<String, AppEntry> userMap = mEntriesMap.get(stats.userHandle);
1052                     if (userMap == null) {
1053                         // The user must have been removed.
1054                         return;
1055                     }
1056                     AppEntry entry = userMap.get(stats.packageName);
1057                     if (entry != null) {
1058                         synchronized (entry) {
1059                             entry.sizeStale = false;
1060                             entry.sizeLoadStart = 0;
1061                             long externalCodeSize = stats.externalCodeSize
1062                                     + stats.externalObbSize;
1063                             long externalDataSize = stats.externalDataSize
1064                                     + stats.externalMediaSize;
1065                             long newSize = externalCodeSize + externalDataSize
1066                                     + getTotalInternalSize(stats);
1067                             if (entry.size != newSize ||
1068                                     entry.cacheSize != stats.cacheSize ||
1069                                     entry.codeSize != stats.codeSize ||
1070                                     entry.dataSize != stats.dataSize ||
1071                                     entry.externalCodeSize != externalCodeSize ||
1072                                     entry.externalDataSize != externalDataSize ||
1073                                     entry.externalCacheSize != stats.externalCacheSize) {
1074                                 entry.size = newSize;
1075                                 entry.cacheSize = stats.cacheSize;
1076                                 entry.codeSize = stats.codeSize;
1077                                 entry.dataSize = stats.dataSize;
1078                                 entry.externalCodeSize = externalCodeSize;
1079                                 entry.externalDataSize = externalDataSize;
1080                                 entry.externalCacheSize = stats.externalCacheSize;
1081                                 entry.sizeStr = getSizeStr(entry.size);
1082                                 entry.internalSize = getTotalInternalSize(stats);
1083                                 entry.internalSizeStr = getSizeStr(entry.internalSize);
1084                                 entry.externalSize = getTotalExternalSize(stats);
1085                                 entry.externalSizeStr = getSizeStr(entry.externalSize);
1086                                 if (DEBUG) Log.i(TAG, "Set size of " + entry.label + " " + entry
1087                                         + ": " + entry.sizeStr);
1088                                 sizeChanged = true;
1089                             }
1090                         }
1091                         if (sizeChanged) {
1092                             Message msg = mMainHandler.obtainMessage(
1093                                     MainHandler.MSG_PACKAGE_SIZE_CHANGED, stats.packageName);
1094                             mMainHandler.sendMessage(msg);
1095                         }
1096                     }
1097                     if (mCurComputingSizePkg != null
1098                             && (mCurComputingSizePkg.equals(stats.packageName)
1099                             && mCurComputingSizeUserId == stats.userHandle)) {
1100                         mCurComputingSizePkg = null;
1101                         sendEmptyMessage(MSG_LOAD_SIZES);
1102                     }
1103                     if (DEBUG_LOCKING) Log.v(TAG, "onGetStatsCompleted releasing lock");
1104                 }
1105             }
1106         };
1107     }
1108
1109     /**
1110      * Receives notifications when applications are added/removed.
1111      */
1112     private class PackageIntentReceiver extends BroadcastReceiver {
1113         void registerReceiver() {
1114             IntentFilter filter = new IntentFilter(Intent.ACTION_PACKAGE_ADDED);
1115             filter.addAction(Intent.ACTION_PACKAGE_REMOVED);
1116             filter.addAction(Intent.ACTION_PACKAGE_CHANGED);
1117             filter.addDataScheme("package");
1118             mContext.registerReceiver(this, filter);
1119             // Register for events related to sdcard installation.
1120             IntentFilter sdFilter = new IntentFilter();
1121             sdFilter.addAction(Intent.ACTION_EXTERNAL_APPLICATIONS_AVAILABLE);
1122             sdFilter.addAction(Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE);
1123             mContext.registerReceiver(this, sdFilter);
1124             // Register for events related to user creation/deletion.
1125             IntentFilter userFilter = new IntentFilter();
1126             userFilter.addAction(Intent.ACTION_USER_ADDED);
1127             userFilter.addAction(Intent.ACTION_USER_REMOVED);
1128             mContext.registerReceiver(this, userFilter);
1129         }
1130         void unregisterReceiver() {
1131             mContext.unregisterReceiver(this);
1132         }
1133         @Override
1134         public void onReceive(Context context, Intent intent) {
1135             String actionStr = intent.getAction();
1136             if (Intent.ACTION_PACKAGE_ADDED.equals(actionStr)) {
1137                 Uri data = intent.getData();
1138                 String pkgName = data.getEncodedSchemeSpecificPart();
1139                 for (int i = 0; i < mEntriesMap.size(); i++) {
1140                     addPackage(pkgName, mEntriesMap.keyAt(i));
1141                 }
1142             } else if (Intent.ACTION_PACKAGE_REMOVED.equals(actionStr)) {
1143                 Uri data = intent.getData();
1144                 String pkgName = data.getEncodedSchemeSpecificPart();
1145                 for (int i = 0; i < mEntriesMap.size(); i++) {
1146                     removePackage(pkgName, mEntriesMap.keyAt(i));
1147                 }
1148             } else if (Intent.ACTION_PACKAGE_CHANGED.equals(actionStr)) {
1149                 Uri data = intent.getData();
1150                 String pkgName = data.getEncodedSchemeSpecificPart();
1151                 for (int i = 0; i < mEntriesMap.size(); i++) {
1152                     invalidatePackage(pkgName, mEntriesMap.keyAt(i));
1153                 }
1154             } else if (Intent.ACTION_EXTERNAL_APPLICATIONS_AVAILABLE.equals(actionStr) ||
1155                     Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE.equals(actionStr)) {
1156                 // When applications become available or unavailable (perhaps because
1157                 // the SD card was inserted or ejected) we need to refresh the
1158                 // AppInfo with new label, icon and size information as appropriate
1159                 // given the newfound (un)availability of the application.
1160                 // A simple way to do that is to treat the refresh as a package
1161                 // removal followed by a package addition.
1162                 String pkgList[] = intent.getStringArrayExtra(Intent.EXTRA_CHANGED_PACKAGE_LIST);
1163                 if (pkgList == null || pkgList.length == 0) {
1164                     // Ignore
1165                     return;
1166                 }
1167                 boolean avail = Intent.ACTION_EXTERNAL_APPLICATIONS_AVAILABLE.equals(actionStr);
1168                 if (avail) {
1169                     for (String pkgName : pkgList) {
1170                         for (int i = 0; i < mEntriesMap.size(); i++) {
1171                             invalidatePackage(pkgName, mEntriesMap.keyAt(i));
1172                         }
1173                     }
1174                 }
1175             } else if (Intent.ACTION_USER_ADDED.equals(actionStr)) {
1176                 addUser(intent.getIntExtra(Intent.EXTRA_USER_HANDLE, UserHandle.USER_NULL));
1177             } else if (Intent.ACTION_USER_REMOVED.equals(actionStr)) {
1178                 removeUser(intent.getIntExtra(Intent.EXTRA_USER_HANDLE, UserHandle.USER_NULL));
1179             }
1180         }
1181     }
1182
1183     public interface Callbacks {
1184         void onRunningStateChanged(boolean running);
1185         void onPackageListChanged();
1186         void onRebuildComplete(ArrayList<AppEntry> apps);
1187         void onPackageIconChanged();
1188         void onPackageSizeChanged(String packageName);
1189         void onAllSizesComputed();
1190         void onLauncherInfoChanged();
1191         void onLoadEntriesCompleted();
1192     }
1193
1194     public static class SizeInfo {
1195         public long cacheSize;
1196         public long codeSize;
1197         public long dataSize;
1198         public long externalCodeSize;
1199         public long externalDataSize;
1200
1201         // This is the part of externalDataSize that is in the cache
1202         // section of external storage.  Note that we don't just combine
1203         // this with cacheSize because currently the platform can't
1204         // automatically trim this data when needed, so it is something
1205         // the user may need to manage.  The externalDataSize also includes
1206         // this value, since what this is here is really the part of
1207         // externalDataSize that we can just consider to be "cache" files
1208         // for purposes of cleaning them up in the app details UI.
1209         public long externalCacheSize;
1210     }
1211
1212     public static class AppEntry extends SizeInfo {
1213         public final File apkFile;
1214         public final long id;
1215         public String label;
1216         public long size;
1217         public long internalSize;
1218         public long externalSize;
1219
1220         public boolean mounted;
1221
1222         /**
1223          * Setting this to {@code true} prevents the entry to be filtered by
1224          * {@link #FILTER_DOWNLOADED_AND_LAUNCHER}.
1225          */
1226         public boolean hasLauncherEntry;
1227
1228         /**
1229          * Whether or not it's a Home app.
1230          */
1231         public boolean isHomeApp;
1232
1233         public String getNormalizedLabel() {
1234             if (normalizedLabel != null) {
1235                 return normalizedLabel;
1236             }
1237             normalizedLabel = normalize(label);
1238             return normalizedLabel;
1239         }
1240
1241         // Need to synchronize on 'this' for the following.
1242         public ApplicationInfo info;
1243         public Drawable icon;
1244         public String sizeStr;
1245         public String internalSizeStr;
1246         public String externalSizeStr;
1247         public boolean sizeStale;
1248         public long sizeLoadStart;
1249
1250         public String normalizedLabel;
1251
1252         // A location where extra info can be placed to be used by custom filters.
1253         public Object extraInfo;
1254
1255         AppEntry(Context context, ApplicationInfo info, long id) {
1256             apkFile = new File(info.sourceDir);
1257             this.id = id;
1258             this.info = info;
1259             this.size = SIZE_UNKNOWN;
1260             this.sizeStale = true;
1261             ensureLabel(context);
1262         }
1263
1264         public void ensureLabel(Context context) {
1265             if (this.label == null || !this.mounted) {
1266                 if (!this.apkFile.exists()) {
1267                     this.mounted = false;
1268                     this.label = info.packageName;
1269                 } else {
1270                     this.mounted = true;
1271                     CharSequence label = info.loadLabel(context.getPackageManager());
1272                     this.label = label != null ? label.toString() : info.packageName;
1273                 }
1274             }
1275         }
1276
1277         boolean ensureIconLocked(Context context, IconDrawableFactory drawableFactory) {
1278             if (this.icon == null) {
1279                 if (this.apkFile.exists()) {
1280                     this.icon = drawableFactory.getBadgedIcon(info);
1281                     return true;
1282                 } else {
1283                     this.mounted = false;
1284                     this.icon = context.getDrawable(R.drawable.sym_app_on_sd_unavailable_icon);
1285                 }
1286             } else if (!this.mounted) {
1287                 // If the app wasn't mounted but is now mounted, reload
1288                 // its icon.
1289                 if (this.apkFile.exists()) {
1290                     this.mounted = true;
1291                     this.icon = drawableFactory.getBadgedIcon(info);
1292                     return true;
1293                 }
1294             }
1295             return false;
1296         }
1297
1298         public String getVersion(Context context) {
1299             try {
1300                 return context.getPackageManager().getPackageInfo(info.packageName, 0).versionName;
1301             } catch (PackageManager.NameNotFoundException e) {
1302                 return "";
1303             }
1304         }
1305     }
1306
1307     /**
1308      * Compare by label, then package name, then uid.
1309      */
1310     public static final Comparator<AppEntry> ALPHA_COMPARATOR = new Comparator<AppEntry>() {
1311         private final Collator sCollator = Collator.getInstance();
1312         @Override
1313         public int compare(AppEntry object1, AppEntry object2) {
1314             int compareResult = sCollator.compare(object1.label, object2.label);
1315             if (compareResult != 0) {
1316                 return compareResult;
1317             }
1318             if (object1.info != null && object2.info != null) {
1319                 compareResult =
1320                     sCollator.compare(object1.info.packageName, object2.info.packageName);
1321                 if (compareResult != 0) {
1322                     return compareResult;
1323                 }
1324             }
1325             return object1.info.uid - object2.info.uid;
1326         }
1327     };
1328
1329     public static final Comparator<AppEntry> SIZE_COMPARATOR
1330             = new Comparator<AppEntry>() {
1331         @Override
1332         public int compare(AppEntry object1, AppEntry object2) {
1333             if (object1.size < object2.size) return 1;
1334             if (object1.size > object2.size) return -1;
1335             return ALPHA_COMPARATOR.compare(object1, object2);
1336         }
1337     };
1338
1339     public static final Comparator<AppEntry> INTERNAL_SIZE_COMPARATOR
1340             = new Comparator<AppEntry>() {
1341         @Override
1342         public int compare(AppEntry object1, AppEntry object2) {
1343             if (object1.internalSize < object2.internalSize) return 1;
1344             if (object1.internalSize > object2.internalSize) return -1;
1345             return ALPHA_COMPARATOR.compare(object1, object2);
1346         }
1347     };
1348
1349     public static final Comparator<AppEntry> EXTERNAL_SIZE_COMPARATOR
1350             = new Comparator<AppEntry>() {
1351         @Override
1352         public int compare(AppEntry object1, AppEntry object2) {
1353             if (object1.externalSize < object2.externalSize) return 1;
1354             if (object1.externalSize > object2.externalSize) return -1;
1355             return ALPHA_COMPARATOR.compare(object1, object2);
1356         }
1357     };
1358
1359     public interface AppFilter {
1360         void init();
1361         default void init(Context context) {
1362             init();
1363         }
1364         boolean filterApp(AppEntry info);
1365     }
1366
1367     public static final AppFilter FILTER_PERSONAL = new AppFilter() {
1368         private int mCurrentUser;
1369
1370         @Override
1371         public void init() {
1372             mCurrentUser = ActivityManager.getCurrentUser();
1373         }
1374
1375         @Override
1376         public boolean filterApp(AppEntry entry) {
1377             return UserHandle.getUserId(entry.info.uid) == mCurrentUser;
1378         }
1379     };
1380
1381     public static final AppFilter FILTER_WITHOUT_DISABLED_UNTIL_USED = new AppFilter() {
1382         @Override
1383         public void init() {
1384             // do nothing
1385         }
1386
1387         @Override
1388         public boolean filterApp(AppEntry entry) {
1389             return entry.info.enabledSetting
1390                     != PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED;
1391         }
1392     };
1393
1394     public static final AppFilter FILTER_WORK = new AppFilter() {
1395         private int mCurrentUser;
1396
1397         @Override
1398         public void init() {
1399             mCurrentUser = ActivityManager.getCurrentUser();
1400         }
1401
1402         @Override
1403         public boolean filterApp(AppEntry entry) {
1404             return UserHandle.getUserId(entry.info.uid) != mCurrentUser;
1405         }
1406     };
1407
1408     /**
1409      * Displays a combined list with "downloaded" and "visible in launcher" apps only.
1410      */
1411     public static final AppFilter FILTER_DOWNLOADED_AND_LAUNCHER = new AppFilter() {
1412         @Override
1413         public void init() {
1414         }
1415
1416         @Override
1417         public boolean filterApp(AppEntry entry) {
1418             if (AppUtils.isInstant(entry.info)) {
1419                 return false;
1420             } else if ((entry.info.flags & ApplicationInfo.FLAG_UPDATED_SYSTEM_APP) != 0) {
1421                 return true;
1422             } else if ((entry.info.flags & ApplicationInfo.FLAG_SYSTEM) == 0) {
1423                 return true;
1424             } else if (entry.hasLauncherEntry) {
1425                 return true;
1426             } else if ((entry.info.flags & ApplicationInfo.FLAG_SYSTEM) != 0 && entry.isHomeApp) {
1427                 return true;
1428             }
1429             return false;
1430         }
1431     };
1432
1433     /**
1434      * Displays a combined list with "downloaded" and "visible in launcher" apps only.
1435      */
1436     public static final AppFilter FILTER_DOWNLOADED_AND_LAUNCHER_AND_INSTANT = new AppFilter() {
1437
1438         @Override
1439         public void init() {
1440         }
1441
1442         @Override
1443         public boolean filterApp(AppEntry entry) {
1444             return AppUtils.isInstant(entry.info)
1445                     || FILTER_DOWNLOADED_AND_LAUNCHER.filterApp(entry);
1446         }
1447
1448     };
1449
1450     public static final AppFilter FILTER_THIRD_PARTY = new AppFilter() {
1451         @Override
1452         public void init() {
1453         }
1454
1455         @Override
1456         public boolean filterApp(AppEntry entry) {
1457             if ((entry.info.flags & ApplicationInfo.FLAG_UPDATED_SYSTEM_APP) != 0) {
1458                 return true;
1459             } else if ((entry.info.flags & ApplicationInfo.FLAG_SYSTEM) == 0) {
1460                 return true;
1461             }
1462             return false;
1463         }
1464     };
1465
1466     public static final AppFilter FILTER_DISABLED = new AppFilter() {
1467         @Override
1468         public void init() {
1469         }
1470
1471         @Override
1472         public boolean filterApp(AppEntry entry) {
1473             return !entry.info.enabled && !AppUtils.isInstant(entry.info);
1474         }
1475     };
1476
1477     public static final AppFilter FILTER_INSTANT = new AppFilter() {
1478         @Override
1479         public void init() {
1480         }
1481
1482         @Override
1483         public boolean filterApp(AppEntry entry) {
1484             return AppUtils.isInstant(entry.info);
1485         }
1486     };
1487
1488     public static final AppFilter FILTER_ALL_ENABLED = new AppFilter() {
1489         @Override
1490         public void init() {
1491         }
1492
1493         @Override
1494         public boolean filterApp(AppEntry entry) {
1495             return entry.info.enabled && !AppUtils.isInstant(entry.info);
1496         }
1497     };
1498
1499     public static final AppFilter FILTER_EVERYTHING = new AppFilter() {
1500         @Override
1501         public void init() {
1502         }
1503
1504         @Override
1505         public boolean filterApp(AppEntry entry) {
1506             return true;
1507         }
1508     };
1509
1510     public static final AppFilter FILTER_WITH_DOMAIN_URLS = new AppFilter() {
1511         @Override
1512         public void init() {
1513         }
1514
1515         @Override
1516         public boolean filterApp(AppEntry entry) {
1517             return !AppUtils.isInstant(entry.info)
1518                 && (entry.info.privateFlags & ApplicationInfo.PRIVATE_FLAG_HAS_DOMAIN_URLS) != 0;
1519         }
1520     };
1521
1522     public static final AppFilter FILTER_NOT_HIDE = new AppFilter() {
1523         private String[] mHidePackageNames;
1524
1525         @Override
1526         public void init(Context context) {
1527             mHidePackageNames = context.getResources()
1528                 .getStringArray(R.array.config_hideWhenDisabled_packageNames);
1529         }
1530
1531         @Override
1532         public void init() {
1533         }
1534
1535         @Override
1536         public boolean filterApp(AppEntry entry) {
1537             if (ArrayUtils.contains(mHidePackageNames, entry.info.packageName)) {
1538                 if (!entry.info.enabled) {
1539                     return false;
1540                 } else if (entry.info.enabledSetting ==
1541                     PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED) {
1542                     return false;
1543                 }
1544             }
1545
1546             return true;
1547         }
1548     };
1549
1550     public static final AppFilter FILTER_GAMES = new AppFilter() {
1551         @Override
1552         public void init() {
1553         }
1554
1555         @Override
1556         public boolean filterApp(ApplicationsState.AppEntry info) {
1557             // TODO: Update for the new game category.
1558             boolean isGame;
1559             synchronized (info.info) {
1560                 isGame = ((info.info.flags & ApplicationInfo.FLAG_IS_GAME) != 0)
1561                         || info.info.category == ApplicationInfo.CATEGORY_GAME;
1562             }
1563             return isGame;
1564         }
1565     };
1566
1567     public static class VolumeFilter implements AppFilter {
1568         private final String mVolumeUuid;
1569
1570         public VolumeFilter(String volumeUuid) {
1571             mVolumeUuid = volumeUuid;
1572         }
1573
1574         @Override
1575         public void init() {
1576         }
1577
1578         @Override
1579         public boolean filterApp(AppEntry info) {
1580             return Objects.equals(info.info.volumeUuid, mVolumeUuid);
1581         }
1582     }
1583
1584     public static class CompoundFilter implements AppFilter {
1585         private final AppFilter mFirstFilter;
1586         private final AppFilter mSecondFilter;
1587
1588         public CompoundFilter(AppFilter first, AppFilter second) {
1589             mFirstFilter = first;
1590             mSecondFilter = second;
1591         }
1592
1593         @Override
1594         public void init(Context context) {
1595             mFirstFilter.init(context);
1596             mSecondFilter.init(context);
1597         }
1598
1599         @Override
1600         public void init() {
1601             mFirstFilter.init();
1602             mSecondFilter.init();
1603         }
1604
1605         @Override
1606         public boolean filterApp(AppEntry info) {
1607             return mFirstFilter.filterApp(info) && mSecondFilter.filterApp(info);
1608         }
1609     }
1610
1611     public static final AppFilter FILTER_AUDIO = new AppFilter() {
1612         @Override
1613         public void init() {
1614         }
1615
1616         @Override
1617         public boolean filterApp(AppEntry entry) {
1618             boolean isMusicApp;
1619             synchronized(entry) {
1620                 isMusicApp = entry.info.category == ApplicationInfo.CATEGORY_AUDIO;
1621             }
1622             return isMusicApp;
1623         }
1624     };
1625
1626     public static final AppFilter FILTER_MOVIES = new AppFilter() {
1627         @Override
1628         public void init() {
1629         }
1630
1631         @Override
1632         public boolean filterApp(AppEntry entry) {
1633             boolean isMovieApp;
1634             synchronized(entry) {
1635                 isMovieApp = entry.info.category == ApplicationInfo.CATEGORY_VIDEO;
1636             }
1637             return isMovieApp;
1638         }
1639     };
1640
1641     public static final AppFilter FILTER_OTHER_APPS =
1642             new AppFilter() {
1643                 @Override
1644                 public void init() {}
1645
1646                 @Override
1647                 public boolean filterApp(AppEntry entry) {
1648                     boolean isCategorized;
1649                     synchronized (entry) {
1650                         isCategorized =
1651                                 FILTER_AUDIO.filterApp(entry)
1652                                         || FILTER_GAMES.filterApp(entry)
1653                                         || FILTER_MOVIES.filterApp(entry);
1654                     }
1655                     return !isCategorized;
1656                 }
1657             };
1658 }