src/com/android/storagemanager/deletionhelper/AppsAsyncLoader.java - platform/packages/apps/StorageManager - Git at Google

 /*
  * Copyright (C) 2017 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.storagemanager.deletionhelper;

 import android.app.usage.UsageStats;
 import android.app.usage.UsageStatsManager;
 import android.content.ComponentName;
 import android.content.Context;
 import android.content.pm.ApplicationInfo;
 import android.content.pm.PackageManager;
 import android.content.pm.ResolveInfo;
 import android.graphics.drawable.Drawable;
 import android.os.SystemProperties;
 import android.os.UserHandle;
 import androidx.annotation.VisibleForTesting;
 import android.text.format.DateUtils;
 import android.util.ArrayMap;
 import android.util.ArraySet;
 import android.util.Log;
 import com.android.settingslib.applications.StorageStatsSource;
 import com.android.settingslib.applications.StorageStatsSource.AppStorageStats;
 import com.android.storagemanager.deletionhelper.AppsAsyncLoader.PackageInfo;
 import com.android.storagemanager.utils.AsyncLoader;

 import java.io.IOException;
 import java.text.Collator;
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.TimeUnit;
 import java.util.Collections;
 import java.util.stream.Collectors;

 /**
  * AppsAsyncLoader is a Loader which loads app storage information and categories it by the app's
  * specified categorization.
  */
 public class AppsAsyncLoader extends AsyncLoader<List<PackageInfo>> {
     private static final String TAG = "AppsAsyncLoader";

     public static final long NEVER_USED = Long.MAX_VALUE;
     public static final long UNKNOWN_LAST_USE = -1;
     public static final long UNUSED_DAYS_DELETION_THRESHOLD = 90;
     public static final long MIN_DELETION_THRESHOLD = Long.MIN_VALUE;
     public static final int NORMAL_THRESHOLD = 0;
     public static final int SIZE_UNKNOWN = -1;
     public static final int SIZE_INVALID = -2;
     public static final int NO_THRESHOLD = 1;
     private static final String DEBUG_APP_UNUSED_OVERRIDE = "debug.asm.app_unused_limit";
     private static final long DAYS_IN_A_TYPICAL_YEAR = 365;

     protected Clock mClock;
     protected AppsAsyncLoader.AppFilter mFilter;
     private int mUserId;
     private String mUuid;
     private StorageStatsSource mStatsManager;
     private PackageManager mPackageManager;

     private UsageStatsManager mUsageStatsManager;

     private AppsAsyncLoader(
             Context context,
             int userId,
             String uuid,
             StorageStatsSource source,
             PackageManager pm,
             UsageStatsManager um,
             AppsAsyncLoader.AppFilter filter) {
         super(context);
         mUserId = userId;
         mUuid = uuid;
         mStatsManager = source;
         mPackageManager = pm;
         mUsageStatsManager = um;
         mClock = new Clock();
         mFilter = filter;
     }

     @Override
     public List<PackageInfo> loadInBackground() {
         return loadApps();
     }

     private List<PackageInfo> loadApps() {
         ArraySet<Integer> seenUid = new ArraySet<>(); // some apps share a uid

         long now = mClock.getCurrentTime();
         long startTime = now - DateUtils.YEAR_IN_MILLIS;
         final Map<String, UsageStats> map =
                 mUsageStatsManager.queryAndAggregateUsageStats(startTime, now);
         final Map<String, UsageStats> alternateMap =
                 getLatestUsageStatsByPackageName(startTime, now);

         List<ApplicationInfo> applicationInfos =
                 mPackageManager.getInstalledApplicationsAsUser(0, mUserId);
         List<PackageInfo> stats = new ArrayList<>();
         int size = applicationInfos.size();
         mFilter.init();
         for (int i = 0; i < size; i++) {
             ApplicationInfo app = applicationInfos.get(i);
             if (seenUid.contains(app.uid)) {
                 continue;
             }

             UsageStats usageStats = map.get(app.packageName);
             UsageStats alternateUsageStats = alternateMap.get(app.packageName);

             final AppStorageStats appSpace;
             try {
                 appSpace = mStatsManager.getStatsForUid(app.volumeUuid, app.uid);
             } catch (IOException e) {
                 Log.w(TAG, e);
                 continue;
             }

             PackageInfo extraInfo =
                     new PackageInfo.Builder()
                             .setDaysSinceLastUse(
                                     getDaysSinceLastUse(
                                             getGreaterUsageStats(
                                                     app.packageName,
                                                     usageStats,
                                                     alternateUsageStats)))
                             .setDaysSinceFirstInstall(getDaysSinceInstalled(app.packageName))
                             .setUserId(UserHandle.getUserId(app.uid))
                             .setPackageName(app.packageName)
                             .setSize(appSpace.getTotalBytes())
                             .setFlags(app.flags)
                             .setIcon(
                                     mPackageManager.getUserBadgedIcon(
                                             mPackageManager.loadUnbadgedItemIcon(app, app),
                                             new UserHandle(UserHandle.getUserId(app.uid))))
                             .setLabel(app.loadLabel(mPackageManager))
                             .build();
             seenUid.add(app.uid);
             if (mFilter.filterApp(extraInfo) && !isDefaultLauncher(mPackageManager, extraInfo)) {
                 stats.add(extraInfo);
             }
         }
         stats.sort(PACKAGE_INFO_COMPARATOR);
         return stats;
     }

     @VisibleForTesting
     UsageStats getGreaterUsageStats(String packageName, UsageStats primary, UsageStats alternate) {
         long primaryLastUsed = primary != null ? primary.getLastTimeUsed() : 0;
         long alternateLastUsed = alternate != null ? alternate.getLastTimeUsed() : 0;

         if (primaryLastUsed != alternateLastUsed) {
             Log.w(
                     TAG,
                     new StringBuilder("Usage stats mismatch for ")
                             .append(packageName)
                             .append(" ")
                             .append(primaryLastUsed)
                             .append(" ")
                             .append(alternateLastUsed)
                             .toString());
         }

         return (primaryLastUsed > alternateLastUsed) ? primary : alternate;
     }

     private Map<String, UsageStats> getLatestUsageStatsByPackageName(long startTime, long endTime) {
         List<UsageStats> usageStats =
                 mUsageStatsManager.queryUsageStats(
                         UsageStatsManager.INTERVAL_YEARLY, startTime, endTime);
         Map<String, List<UsageStats>> groupedByPackageName =
                 usageStats.stream().collect(Collectors.groupingBy(UsageStats::getPackageName));

         ArrayMap<String, UsageStats> latestStatsByPackageName = new ArrayMap<>();
         groupedByPackageName
                 .entrySet()
                 .stream()
                 .forEach(
                         // Flattens the list of UsageStats to only have the latest by
                         // getLastTimeUsed, retaining the package name as the key.
                         (Map.Entry<String, List<UsageStats>> item) -> {
                             latestStatsByPackageName.put(
                                     item.getKey(),
                                     Collections.max(
                                             item.getValue(),
                                             (UsageStats o1, UsageStats o2) ->
                                                     Long.compare(
                                                             o1.getLastTimeUsed(),
                                                             o2.getLastTimeUsed())));
                         });

         return latestStatsByPackageName;
     }

     @Override
     protected void onDiscardResult(List<PackageInfo> result) {}

     private static boolean isDefaultLauncher(PackageManager packageManager, PackageInfo info) {
         if (packageManager == null) {
             return false;
         }

         final List<ResolveInfo> homeActivities = new ArrayList<>();
         ComponentName defaultActivity = packageManager.getHomeActivities(homeActivities);
         if (defaultActivity != null) {
             String packageName = defaultActivity.getPackageName();
             return packageName == null
                     ? false
                     : defaultActivity.getPackageName().equals(info.packageName);
         }

         return false;
     }

     public static class Builder {
         private Context mContext;
         private int mUid;
         private String mUuid;
         private StorageStatsSource mStorageStatsSource;
         private PackageManager mPackageManager;
         private UsageStatsManager mUsageStatsManager;
         private AppsAsyncLoader.AppFilter mFilter;

         public Builder(Context context) {
             mContext = context;
         }

         public Builder setUid(int uid) {
             mUid = uid;
             return this;
         }

         public Builder setUuid(String uuid) {
             this.mUuid = uuid;
             return this;
         }

         public Builder setStorageStatsSource(StorageStatsSource storageStatsSource) {
             this.mStorageStatsSource = storageStatsSource;
             return this;
         }

         public Builder setPackageManager(PackageManager packageManager) {
             this.mPackageManager = packageManager;
             return this;
         }

         public Builder setUsageStatsManager(UsageStatsManager usageStatsManager) {
             this.mUsageStatsManager = usageStatsManager;
             return this;
         }

         public Builder setFilter(AppFilter filter) {
             this.mFilter = filter;
             return this;
         }

         public AppsAsyncLoader build() {
             return new AppsAsyncLoader(
                     mContext,
                     mUid,
                     mUuid,
                     mStorageStatsSource,
                     mPackageManager,
                     mUsageStatsManager,
                     mFilter);
         }
     }

     /**
      * Comparator that checks PackageInfo to see if it describes the same app based on the name and
      * user it belongs to. This comparator does NOT fulfill the standard java equality contract
      * because it only checks a few fields.
      */
     public static final Comparator<PackageInfo> PACKAGE_INFO_COMPARATOR =
             new Comparator<PackageInfo>() {
                 private final Collator sCollator = Collator.getInstance();

                 @Override
                 public int compare(PackageInfo object1, PackageInfo object2) {
                     if (object1.size < object2.size) return 1;
                     if (object1.size > object2.size) return -1;
                     int compareResult = sCollator.compare(object1.label, object2.label);
                     if (compareResult != 0) {
                         return compareResult;
                     }
                     compareResult = sCollator.compare(object1.packageName, object2.packageName);
                     if (compareResult != 0) {
                         return compareResult;
                     }
                     return object1.userId - object2.userId;
                 }
             };

     public static final AppFilter FILTER_NO_THRESHOLD =
             new AppFilter() {
                 @Override
                 public void init() {}

                 @Override
                 public boolean filterApp(PackageInfo info) {
                     if (info == null) {
                         return false;
                     }
                     return !isBundled(info)
                             && !isPersistentProcess(info)
                             && isExtraInfoValid(info, MIN_DELETION_THRESHOLD);
                 }
             };

     /**
      * Filters only non-system apps which haven't been used in the last 60 days. If an app's last
      * usage is unknown, it is skipped.
      */
     public static final AppFilter FILTER_USAGE_STATS =
             new AppFilter() {
                 private long mUnusedDaysThreshold;

                 @Override
                 public void init() {
                     mUnusedDaysThreshold =
                             SystemProperties.getLong(
                                     DEBUG_APP_UNUSED_OVERRIDE, UNUSED_DAYS_DELETION_THRESHOLD);
                 }

                 @Override
                 public boolean filterApp(PackageInfo info) {
                     if (info == null) {
                         return false;
                     }
                     return !isBundled(info)
                             && !isPersistentProcess(info)
                             && isExtraInfoValid(info, mUnusedDaysThreshold);
                 }
             };

     private static boolean isBundled(PackageInfo info) {
         return (info.flags & ApplicationInfo.FLAG_SYSTEM) != 0;
     }

     private static boolean isPersistentProcess(PackageInfo info) {
         return (info.flags & ApplicationInfo.FLAG_PERSISTENT) != 0;
     }

     private static boolean isExtraInfoValid(Object extraInfo, long unusedDaysThreshold) {
         if (extraInfo == null || !(extraInfo instanceof PackageInfo)) {
             return false;
         }

         PackageInfo state = (PackageInfo) extraInfo;

         // If we are missing information, let's be conservative and not show it.
         if (state.daysSinceFirstInstall == UNKNOWN_LAST_USE
                 || state.daysSinceLastUse == UNKNOWN_LAST_USE) {
             Log.w(TAG, "Missing information. Skipping app");
             return false;
         }

         // If the app has never been used, daysSinceLastUse is Long.MAX_VALUE, so the first
         // install is always the most recent use.
         long mostRecentUse = Math.min(state.daysSinceFirstInstall, state.daysSinceLastUse);
         if (mostRecentUse >= unusedDaysThreshold) {
             Log.i(TAG, "Accepting " + state.packageName + " with a minimum of " + mostRecentUse);
         }
         return mostRecentUse >= unusedDaysThreshold;
     }

     private long getDaysSinceLastUse(UsageStats stats) {
         if (stats == null) {
             return NEVER_USED;
         }
         long lastUsed = stats.getLastTimeUsed();
         // Sometimes, a usage is recorded without a time and we don't know when the use was.
         if (lastUsed <= 0) {
             return UNKNOWN_LAST_USE;
         }

         // Theoretically, this should be impossible, but UsageStatsService, uh, finds a way.
         long days = (TimeUnit.MILLISECONDS.toDays(mClock.getCurrentTime() - lastUsed));
         if (days > DAYS_IN_A_TYPICAL_YEAR) {
             return NEVER_USED;
         }
         return days;
     }

     private long getDaysSinceInstalled(String packageName) {
         android.content.pm.PackageInfo pi = null;
         try {
             pi = mPackageManager.getPackageInfo(packageName, 0);
         } catch (PackageManager.NameNotFoundException e) {
             Log.e(TAG, packageName + " was not found.");
         }

         if (pi == null) {
             return UNKNOWN_LAST_USE;
         }
         return (TimeUnit.MILLISECONDS.toDays(mClock.getCurrentTime() - pi.firstInstallTime));
     }

     public interface AppFilter {

         /**
          * Note: This method must be manually called before using an app filter. It does not get
          * called on construction.
          */
         void init();

         default void init(Context context) {
             init();
         }

         /**
          * Returns true or false depending on whether the app should be filtered or not.
          *
          * @param info the PackageInfo for the app in question.
          * @return true if the app should be included, false if it should be filtered out.
          */
         boolean filterApp(PackageInfo info);
     }

     /** PackageInfo contains all the information needed to present apps for deletion to users. */
     public static class PackageInfo {

         public long daysSinceLastUse;
         public long daysSinceFirstInstall;
         public int userId;
         public String packageName;
         public long size;
         public Drawable icon;
         public CharSequence label;
         /**
          * Flags from {@link ApplicationInfo} that set whether the app is a regular app or something
          * special like a system app.
          */
         public int flags;

         private PackageInfo(
                 long daysSinceLastUse,
                 long daysSinceFirstInstall,
                 int userId,
                 String packageName,
                 long size,
                 int flags,
                 Drawable icon,
                 CharSequence label) {
             this.daysSinceLastUse = daysSinceLastUse;
             this.daysSinceFirstInstall = daysSinceFirstInstall;
             this.userId = userId;
             this.packageName = packageName;
             this.size = size;
             this.flags = flags;
             this.icon = icon;
             this.label = label;
         }

         public static class Builder {
             private long mDaysSinceLastUse;
             private long mDaysSinceFirstInstall;
             private int mUserId;
             private String mPackageName;
             private long mSize;
             private int mFlags;
             private Drawable mIcon;
             private CharSequence mLabel;

             public Builder setDaysSinceLastUse(long daysSinceLastUse) {
                 this.mDaysSinceLastUse = daysSinceLastUse;
                 return this;
             }

             public Builder setDaysSinceFirstInstall(long daysSinceFirstInstall) {
                 this.mDaysSinceFirstInstall = daysSinceFirstInstall;
                 return this;
             }

             public Builder setUserId(int userId) {
                 this.mUserId = userId;
                 return this;
             }

             public Builder setPackageName(String packageName) {
                 this.mPackageName = packageName;
                 return this;
             }

             public Builder setSize(long size) {
                 this.mSize = size;
                 return this;
             }

             public Builder setFlags(int flags) {
                 this.mFlags = flags;
                 return this;
             }

             public Builder setIcon(Drawable icon) {
                 this.mIcon = icon;
                 return this;
             }

             public Builder setLabel(CharSequence label) {
                 this.mLabel = label;
                 return this;
             }

             public PackageInfo build() {
                 return new PackageInfo(
                         mDaysSinceLastUse,
                         mDaysSinceFirstInstall,
                         mUserId,
                         mPackageName,
                         mSize,
                         mFlags,
                         mIcon,
                         mLabel);
             }
         }
     }

     /** Clock provides the current time. */
     static class Clock {
         public long getCurrentTime() {
             return System.currentTimeMillis();
         }
     }
 }
	/*
	* Copyright (C) 2017 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.android.storagemanager.deletionhelper;

	import android.app.usage.UsageStats;
	import android.app.usage.UsageStatsManager;
	import android.content.ComponentName;
	import android.content.Context;
	import android.content.pm.ApplicationInfo;
	import android.content.pm.PackageManager;
	import android.content.pm.ResolveInfo;
	import android.graphics.drawable.Drawable;
	import android.os.SystemProperties;
	import android.os.UserHandle;
	import androidx.annotation.VisibleForTesting;
	import android.text.format.DateUtils;
	import android.util.ArrayMap;
	import android.util.ArraySet;
	import android.util.Log;
	import com.android.settingslib.applications.StorageStatsSource;
	import com.android.settingslib.applications.StorageStatsSource.AppStorageStats;
	import com.android.storagemanager.deletionhelper.AppsAsyncLoader.PackageInfo;
	import com.android.storagemanager.utils.AsyncLoader;

	import java.io.IOException;
	import java.text.Collator;
	import java.util.ArrayList;
	import java.util.Comparator;
	import java.util.List;
	import java.util.Map;
	import java.util.concurrent.TimeUnit;
	import java.util.Collections;
	import java.util.stream.Collectors;

	/**
	* AppsAsyncLoader is a Loader which loads app storage information and categories it by the app's
	* specified categorization.
	*/
	public class AppsAsyncLoader extends AsyncLoader<List<PackageInfo>> {
	private static final String TAG = "AppsAsyncLoader";

	public static final long NEVER_USED = Long.MAX_VALUE;
	public static final long UNKNOWN_LAST_USE = -1;
	public static final long UNUSED_DAYS_DELETION_THRESHOLD = 90;
	public static final long MIN_DELETION_THRESHOLD = Long.MIN_VALUE;
	public static final int NORMAL_THRESHOLD = 0;
	public static final int SIZE_UNKNOWN = -1;
	public static final int SIZE_INVALID = -2;
	public static final int NO_THRESHOLD = 1;
	private static final String DEBUG_APP_UNUSED_OVERRIDE = "debug.asm.app_unused_limit";
	private static final long DAYS_IN_A_TYPICAL_YEAR = 365;

	protected Clock mClock;
	protected AppsAsyncLoader.AppFilter mFilter;
	private int mUserId;
	private String mUuid;
	private StorageStatsSource mStatsManager;
	private PackageManager mPackageManager;

	private UsageStatsManager mUsageStatsManager;

	private AppsAsyncLoader(
	Context context,
	int userId,
	String uuid,
	StorageStatsSource source,
	PackageManager pm,
	UsageStatsManager um,
	AppsAsyncLoader.AppFilter filter) {
	super(context);
	mUserId = userId;
	mUuid = uuid;
	mStatsManager = source;
	mPackageManager = pm;
	mUsageStatsManager = um;
	mClock = new Clock();
	mFilter = filter;
	}

	@Override
	public List<PackageInfo> loadInBackground() {
	return loadApps();
	}

	private List<PackageInfo> loadApps() {
	ArraySet<Integer> seenUid = new ArraySet<>(); // some apps share a uid

	long now = mClock.getCurrentTime();
	long startTime = now - DateUtils.YEAR_IN_MILLIS;
	final Map<String, UsageStats> map =
	mUsageStatsManager.queryAndAggregateUsageStats(startTime, now);
	final Map<String, UsageStats> alternateMap =
	getLatestUsageStatsByPackageName(startTime, now);

	List<ApplicationInfo> applicationInfos =
	mPackageManager.getInstalledApplicationsAsUser(0, mUserId);
	List<PackageInfo> stats = new ArrayList<>();
	int size = applicationInfos.size();
	mFilter.init();
	for (int i = 0; i < size; i++) {
	ApplicationInfo app = applicationInfos.get(i);
	if (seenUid.contains(app.uid)) {
	continue;
	}

	UsageStats usageStats = map.get(app.packageName);
	UsageStats alternateUsageStats = alternateMap.get(app.packageName);

	final AppStorageStats appSpace;
	try {
	appSpace = mStatsManager.getStatsForUid(app.volumeUuid, app.uid);
	} catch (IOException e) {
	Log.w(TAG, e);
	continue;
	}

	PackageInfo extraInfo =
	new PackageInfo.Builder()
	.setDaysSinceLastUse(
	getDaysSinceLastUse(
	getGreaterUsageStats(
	app.packageName,
	usageStats,
	alternateUsageStats)))
	.setDaysSinceFirstInstall(getDaysSinceInstalled(app.packageName))
	.setUserId(UserHandle.getUserId(app.uid))
	.setPackageName(app.packageName)
	.setSize(appSpace.getTotalBytes())
	.setFlags(app.flags)
	.setIcon(
	mPackageManager.getUserBadgedIcon(
	mPackageManager.loadUnbadgedItemIcon(app, app),
	new UserHandle(UserHandle.getUserId(app.uid))))
	.setLabel(app.loadLabel(mPackageManager))
	.build();
	seenUid.add(app.uid);
	if (mFilter.filterApp(extraInfo) && !isDefaultLauncher(mPackageManager, extraInfo)) {
	stats.add(extraInfo);
	}
	}
	stats.sort(PACKAGE_INFO_COMPARATOR);
	return stats;
	}

	@VisibleForTesting
	UsageStats getGreaterUsageStats(String packageName, UsageStats primary, UsageStats alternate) {
	long primaryLastUsed = primary != null ? primary.getLastTimeUsed() : 0;
	long alternateLastUsed = alternate != null ? alternate.getLastTimeUsed() : 0;

	if (primaryLastUsed != alternateLastUsed) {
	Log.w(
	TAG,
	new StringBuilder("Usage stats mismatch for ")
	.append(packageName)
	.append(" ")
	.append(primaryLastUsed)
	.append(" ")
	.append(alternateLastUsed)
	.toString());
	}

	return (primaryLastUsed > alternateLastUsed) ? primary : alternate;
	}

	private Map<String, UsageStats> getLatestUsageStatsByPackageName(long startTime, long endTime) {
	List<UsageStats> usageStats =
	mUsageStatsManager.queryUsageStats(
	UsageStatsManager.INTERVAL_YEARLY, startTime, endTime);
	Map<String, List<UsageStats>> groupedByPackageName =
	usageStats.stream().collect(Collectors.groupingBy(UsageStats::getPackageName));

	ArrayMap<String, UsageStats> latestStatsByPackageName = new ArrayMap<>();
	groupedByPackageName
	.entrySet()
	.stream()
	.forEach(
	// Flattens the list of UsageStats to only have the latest by
	// getLastTimeUsed, retaining the package name as the key.
	(Map.Entry<String, List<UsageStats>> item) -> {
	latestStatsByPackageName.put(
	item.getKey(),
	Collections.max(
	item.getValue(),
	(UsageStats o1, UsageStats o2) ->
	Long.compare(
	o1.getLastTimeUsed(),
	o2.getLastTimeUsed())));
	});

	return latestStatsByPackageName;
	}

	@Override
	protected void onDiscardResult(List<PackageInfo> result) {}

	private static boolean isDefaultLauncher(PackageManager packageManager, PackageInfo info) {
	if (packageManager == null) {
	return false;
	}

	final List<ResolveInfo> homeActivities = new ArrayList<>();
	ComponentName defaultActivity = packageManager.getHomeActivities(homeActivities);
	if (defaultActivity != null) {
	String packageName = defaultActivity.getPackageName();
	return packageName == null
	? false
	: defaultActivity.getPackageName().equals(info.packageName);
	}

	return false;
	}

	public static class Builder {
	private Context mContext;
	private int mUid;
	private String mUuid;
	private StorageStatsSource mStorageStatsSource;
	private PackageManager mPackageManager;
	private UsageStatsManager mUsageStatsManager;
	private AppsAsyncLoader.AppFilter mFilter;

	public Builder(Context context) {
	mContext = context;
	}

	public Builder setUid(int uid) {
	mUid = uid;
	return this;
	}

	public Builder setUuid(String uuid) {
	this.mUuid = uuid;
	return this;
	}

	public Builder setStorageStatsSource(StorageStatsSource storageStatsSource) {
	this.mStorageStatsSource = storageStatsSource;
	return this;
	}

	public Builder setPackageManager(PackageManager packageManager) {
	this.mPackageManager = packageManager;
	return this;
	}

	public Builder setUsageStatsManager(UsageStatsManager usageStatsManager) {
	this.mUsageStatsManager = usageStatsManager;
	return this;
	}

	public Builder setFilter(AppFilter filter) {
	this.mFilter = filter;
	return this;
	}

	public AppsAsyncLoader build() {
	return new AppsAsyncLoader(
	mContext,
	mUid,
	mUuid,
	mStorageStatsSource,
	mPackageManager,
	mUsageStatsManager,
	mFilter);
	}
	}

	/**
	* Comparator that checks PackageInfo to see if it describes the same app based on the name and
	* user it belongs to. This comparator does NOT fulfill the standard java equality contract
	* because it only checks a few fields.
	*/
	public static final Comparator<PackageInfo> PACKAGE_INFO_COMPARATOR =
	new Comparator<PackageInfo>() {
	private final Collator sCollator = Collator.getInstance();

	@Override
	public int compare(PackageInfo object1, PackageInfo object2) {
	if (object1.size < object2.size) return 1;
	if (object1.size > object2.size) return -1;
	int compareResult = sCollator.compare(object1.label, object2.label);
	if (compareResult != 0) {
	return compareResult;
	}
	compareResult = sCollator.compare(object1.packageName, object2.packageName);
	if (compareResult != 0) {
	return compareResult;
	}
	return object1.userId - object2.userId;
	}
	};

	public static final AppFilter FILTER_NO_THRESHOLD =
	new AppFilter() {
	@Override
	public void init() {}

	@Override
	public boolean filterApp(PackageInfo info) {
	if (info == null) {
	return false;
	}
	return !isBundled(info)
	&& !isPersistentProcess(info)
	&& isExtraInfoValid(info, MIN_DELETION_THRESHOLD);
	}
	};

	/**
	* Filters only non-system apps which haven't been used in the last 60 days. If an app's last
	* usage is unknown, it is skipped.
	*/
	public static final AppFilter FILTER_USAGE_STATS =
	new AppFilter() {
	private long mUnusedDaysThreshold;

	@Override
	public void init() {
	mUnusedDaysThreshold =
	SystemProperties.getLong(
	DEBUG_APP_UNUSED_OVERRIDE, UNUSED_DAYS_DELETION_THRESHOLD);
	}

	@Override
	public boolean filterApp(PackageInfo info) {
	if (info == null) {
	return false;
	}
	return !isBundled(info)
	&& !isPersistentProcess(info)
	&& isExtraInfoValid(info, mUnusedDaysThreshold);
	}
	};

	private static boolean isBundled(PackageInfo info) {
	return (info.flags & ApplicationInfo.FLAG_SYSTEM) != 0;
	}

	private static boolean isPersistentProcess(PackageInfo info) {
	return (info.flags & ApplicationInfo.FLAG_PERSISTENT) != 0;
	}

	private static boolean isExtraInfoValid(Object extraInfo, long unusedDaysThreshold) {
	if (extraInfo == null \|\| !(extraInfo instanceof PackageInfo)) {
	return false;
	}

	PackageInfo state = (PackageInfo) extraInfo;

	// If we are missing information, let's be conservative and not show it.
	if (state.daysSinceFirstInstall == UNKNOWN_LAST_USE
	\|\| state.daysSinceLastUse == UNKNOWN_LAST_USE) {
	Log.w(TAG, "Missing information. Skipping app");
	return false;
	}

	// If the app has never been used, daysSinceLastUse is Long.MAX_VALUE, so the first
	// install is always the most recent use.
	long mostRecentUse = Math.min(state.daysSinceFirstInstall, state.daysSinceLastUse);
	if (mostRecentUse >= unusedDaysThreshold) {
	Log.i(TAG, "Accepting " + state.packageName + " with a minimum of " + mostRecentUse);
	}
	return mostRecentUse >= unusedDaysThreshold;
	}

	private long getDaysSinceLastUse(UsageStats stats) {
	if (stats == null) {
	return NEVER_USED;
	}
	long lastUsed = stats.getLastTimeUsed();
	// Sometimes, a usage is recorded without a time and we don't know when the use was.
	if (lastUsed <= 0) {
	return UNKNOWN_LAST_USE;
	}

	// Theoretically, this should be impossible, but UsageStatsService, uh, finds a way.
	long days = (TimeUnit.MILLISECONDS.toDays(mClock.getCurrentTime() - lastUsed));
	if (days > DAYS_IN_A_TYPICAL_YEAR) {
	return NEVER_USED;
	}
	return days;
	}

	private long getDaysSinceInstalled(String packageName) {
	android.content.pm.PackageInfo pi = null;
	try {
	pi = mPackageManager.getPackageInfo(packageName, 0);
	} catch (PackageManager.NameNotFoundException e) {
	Log.e(TAG, packageName + " was not found.");
	}

	if (pi == null) {
	return UNKNOWN_LAST_USE;
	}
	return (TimeUnit.MILLISECONDS.toDays(mClock.getCurrentTime() - pi.firstInstallTime));
	}

	public interface AppFilter {

	/**
	* Note: This method must be manually called before using an app filter. It does not get
	* called on construction.
	*/
	void init();

	default void init(Context context) {
	init();
	}

	/**
	* Returns true or false depending on whether the app should be filtered or not.
	*
	* @param info the PackageInfo for the app in question.
	* @return true if the app should be included, false if it should be filtered out.
	*/
	boolean filterApp(PackageInfo info);
	}

	/** PackageInfo contains all the information needed to present apps for deletion to users. */
	public static class PackageInfo {

	public long daysSinceLastUse;
	public long daysSinceFirstInstall;
	public int userId;
	public String packageName;
	public long size;
	public Drawable icon;
	public CharSequence label;
	/**
	* Flags from {@link ApplicationInfo} that set whether the app is a regular app or something
	* special like a system app.
	*/
	public int flags;

	private PackageInfo(
	long daysSinceLastUse,
	long daysSinceFirstInstall,
	int userId,
	String packageName,
	long size,
	int flags,
	Drawable icon,
	CharSequence label) {
	this.daysSinceLastUse = daysSinceLastUse;
	this.daysSinceFirstInstall = daysSinceFirstInstall;
	this.userId = userId;
	this.packageName = packageName;
	this.size = size;
	this.flags = flags;
	this.icon = icon;
	this.label = label;
	}

	public static class Builder {
	private long mDaysSinceLastUse;
	private long mDaysSinceFirstInstall;
	private int mUserId;
	private String mPackageName;
	private long mSize;
	private int mFlags;
	private Drawable mIcon;
	private CharSequence mLabel;

	public Builder setDaysSinceLastUse(long daysSinceLastUse) {
	this.mDaysSinceLastUse = daysSinceLastUse;
	return this;
	}

	public Builder setDaysSinceFirstInstall(long daysSinceFirstInstall) {
	this.mDaysSinceFirstInstall = daysSinceFirstInstall;
	return this;
	}

	public Builder setUserId(int userId) {
	this.mUserId = userId;
	return this;
	}

	public Builder setPackageName(String packageName) {
	this.mPackageName = packageName;
	return this;
	}

	public Builder setSize(long size) {
	this.mSize = size;
	return this;
	}

	public Builder setFlags(int flags) {
	this.mFlags = flags;
	return this;
	}

	public Builder setIcon(Drawable icon) {
	this.mIcon = icon;
	return this;
	}

	public Builder setLabel(CharSequence label) {
	this.mLabel = label;
	return this;
	}

	public PackageInfo build() {
	return new PackageInfo(
	mDaysSinceLastUse,
	mDaysSinceFirstInstall,
	mUserId,
	mPackageName,
	mSize,
	mFlags,
	mIcon,
	mLabel);
	}
	}
	}

	/** Clock provides the current time. */
	static class Clock {
	public long getCurrentTime() {
	return System.currentTimeMillis();
	}
	}
	}