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