android.app.ActivityManager.RunningTaskInfo#android.app.usage.UsageStatsManager源码实例Demo

@Override
public void onAppIdleStateChanged(String packageName, int userId, boolean idle,
        int bucket, int reason) {
    if (DEBUG) {
        Slog.d(TAG,"onAppIdleStateChanged: " + packageName + " u" + userId
                + (idle ? " idle" : " active") + " " + bucket);
    }
    final boolean changed;
    if (bucket == UsageStatsManager.STANDBY_BUCKET_EXEMPTED) {
        changed = mExemptedPackages.add(userId, packageName);
    } else {
        changed = mExemptedPackages.remove(userId, packageName);
    }
    if (changed) {
        mHandler.notifyExemptChanged();
    }
}
 

/**
 * Return the minimum time that should elapse before an app in the specified bucket
 * can receive alarms again
 */
private long getMinDelayForBucketLocked(int bucket) {
    // UsageStats bucket values are treated as floors of their behavioral range.
    // In other words, a bucket value between WORKING and ACTIVE is treated as
    // WORKING, not as ACTIVE.  The ACTIVE and NEVER bucket apply only at specific
    // values.
    final int index;

    if (bucket == UsageStatsManager.STANDBY_BUCKET_NEVER) index = NEVER_INDEX;
    else if (bucket > UsageStatsManager.STANDBY_BUCKET_FREQUENT) index = RARE_INDEX;
    else if (bucket > UsageStatsManager.STANDBY_BUCKET_WORKING_SET) index = FREQUENT_INDEX;
    else if (bucket > UsageStatsManager.STANDBY_BUCKET_ACTIVE) index = WORKING_INDEX;
    else index = ACTIVE_INDEX;

    return mConstants.APP_STANDBY_MIN_DELAYS[index];
}
 

private int bucketNameToBucketValue(String name) {
    String lower = name.toLowerCase();
    if (lower.startsWith("ac")) {
        return UsageStatsManager.STANDBY_BUCKET_ACTIVE;
    } else if (lower.startsWith("wo")) {
        return UsageStatsManager.STANDBY_BUCKET_WORKING_SET;
    } else if (lower.startsWith("fr")) {
        return UsageStatsManager.STANDBY_BUCKET_FREQUENT;
    } else if (lower.startsWith("ra")) {
        return UsageStatsManager.STANDBY_BUCKET_RARE;
    } else if (lower.startsWith("ne")) {
        return UsageStatsManager.STANDBY_BUCKET_NEVER;
    } else {
        try {
            int bucket = Integer.parseInt(lower);
            return bucket;
        } catch (NumberFormatException nfe) {
            getErrPrintWriter().println("Error: Unknown bucket: " + name);
        }
    }
    return -1;
}
 

@Override
public void onReceive(Context context, Intent intent) {
    // Save usage statistics right now!
    // We need to use the statics at this moment
    // for "skipping foreground apps"
    // No app is foreground after the screen is locked.
    mScreenLockTime = new Date().getTime();
    if (SettingsManager.getInstance().getSkipForegroundEnabled() &&
            Utility.checkUsageStatsPermission(FreezeService.this)) {
        UsageStatsManager usm = getSystemService(UsageStatsManager.class);
        mUsageStats = usm.queryAndAggregateUsageStats(mScreenLockTime - APP_INACTIVE_TIMEOUT, mScreenLockTime);
    }

    // Delay the work so that it can be canceled if the screen
    // gets unlocked before the delay passes
    mHandler.postDelayed(mFreezeWork,
            ((long) SettingsManager.getInstance().getAutoFreezeDelay()) * 1000);
    registerReceiver(mUnlockReceiver, new IntentFilter(Intent.ACTION_SCREEN_ON));
}
 

/** Produces a map for each installed app package name,
 * with the corresponding time in foreground in seconds for that application.
 */
@SuppressWarnings("ResourceType")
public static HashMap<String, Double> getUsageMap(Context context, long start, long end) {
    UsageStatsManager manager = (UsageStatsManager) context.getSystemService("usagestats");
    Map<String, UsageStats> usageStatsMap = manager.queryAndAggregateUsageStats(start, end);
    HashMap<String, Double> usageMap = new HashMap<>();

    for (String packageName : usageStatsMap.keySet()) {
        UsageStats us = usageStatsMap.get(packageName);
        try {
            long timeMs = us.getTotalTimeInForeground();
            Double timeSeconds = new Double(timeMs / 1000);
            usageMap.put(packageName, timeSeconds);
        } catch (Exception e) {
            Log.d(TAG, "Getting timeInForeground resulted in an exception");
        }
    }
    return usageMap;
}
 

public static String getForegroundPackage(UsageStatsManager usageStatsManager) {
    String packageName = null;

    final long INTERVAL = 1000 * 60;
    final long end = System.currentTimeMillis();
    final long begin = end - INTERVAL;
    final UsageEvents usageEvents = usageStatsManager.queryEvents(begin, end);
    while (usageEvents.hasNextEvent()) {
        UsageEvents.Event event = new UsageEvents.Event();
        usageEvents.getNextEvent(event);
        switch (event.getEventType()) {
            case UsageEvents.Event.MOVE_TO_FOREGROUND:
                packageName = event.getPackageName();
                break;
            case UsageEvents.Event.MOVE_TO_BACKGROUND:
                if (event.getPackageName().equals(packageName)) {
                    packageName = null;
                }
        }
    }

    return packageName;
}
 

private String currentPackage() {
    if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.LOLLIPOP) {
        UsageStatsManager usm = (UsageStatsManager) getSystemService(USAGE_STATS_SERVICE);
        long time = System.currentTimeMillis();
        List<UsageStats> appList = usm.queryUsageStats(UsageStatsManager.INTERVAL_DAILY,
                time - 1000 * 1000, time);
        if (appList != null && appList.size() > 0) {
            SortedMap<Long, UsageStats> mySortedMap = new TreeMap<Long, UsageStats>();
            for (UsageStats usageStats : appList) {
                mySortedMap.put(usageStats.getLastTimeUsed(),
                        usageStats);
            }
            if (mySortedMap != null && !mySortedMap.isEmpty()) {
                return mySortedMap.get(
                        mySortedMap.lastKey()).getPackageName();
            }
        }
    }

    return currentTask().topActivity.getPackageName();
}
 

@SuppressWarnings("WrongConstant")
public static String getForegroundAppPackageName(Context context) {
    UsageStatsManager manager = (UsageStatsManager) context.getSystemService("usagestats");
    long time = System.currentTimeMillis();
    List<UsageStats> list = manager.queryUsageStats(UsageStatsManager.INTERVAL_DAILY,
            time - 1000 * 1000, time);
    if (list != null && !list.isEmpty()) {
        SortedMap<Long, UsageStats> map = new TreeMap<>();
        for (UsageStats stats : list) {
            map.put(stats.getLastTimeUsed(), stats);
        }

        if (!map.isEmpty()) {
            return map.get(map.lastKey()).getPackageName();
        }
    }

    return null;
}
 

@SuppressWarnings("ResourceType")
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public static ArrayList<UsageEvents.Event> getEventList(Context context, long startTime, long endTime){
    ArrayList<UsageEvents.Event> mEventList = new ArrayList<>();

    Log.i(TAG," EventUtils-getEventList()   Range start:" + startTime);
    Log.i(TAG," EventUtils-getEventList()   Range end:" +endTime);
    Log.i(TAG," EventUtils-getEventList()   Range start:" + dateFormat.format(startTime));
    Log.i(TAG," EventUtils-getEventList()   Range end:" + dateFormat.format(endTime));

    UsageStatsManager mUsmManager = (UsageStatsManager) context.getSystemService("usagestats");
    UsageEvents events = mUsmManager.queryEvents(startTime, endTime);

    while (events.hasNextEvent()) {
        UsageEvents.Event e = new UsageEvents.Event();
        events.getNextEvent(e);
        if (e != null && (e.getEventType() == 1 || e.getEventType() == 2)) {
            Log.i(TAG," EventUtils-getEventList()  "+e.getTimeStamp()+"   event:" + e.getClassName() + "   type = " + e.getEventType());
            mEventList.add(e);
        }
    }

    return mEventList;
}
 

@SuppressWarnings("ResourceType")
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public static ArrayList<UsageStats> getUsageList(Context context, long startTime, long endTime) {

    Log.i(TAG," EventUtils-getUsageList()   Range start:" + startTime);
    Log.i(TAG," EventUtils-getUsageList()   Range end:" + endTime);
    Log.i(TAG," EventUtils-getUsageList()   Range start:" + dateFormat.format(startTime));
    Log.i(TAG," EventUtils-getUsageList()   Range end:" + dateFormat.format(endTime));

    ArrayList<UsageStats> list = new ArrayList<>();

    UsageStatsManager mUsmManager = (UsageStatsManager) context.getSystemService("usagestats");
    Map<String, UsageStats> map = mUsmManager.queryAndAggregateUsageStats(startTime, endTime);
    for (Map.Entry<String, UsageStats> entry : map.entrySet()) {
        UsageStats stats = entry.getValue();
        if(stats.getTotalTimeInForeground() > 0){
            list.add(stats);
            Log.i(TAG," EventUtils-getUsageList()   stats:" + stats.getPackageName() + "   TotalTimeInForeground = " + stats.getTotalTimeInForeground());
        }
    }

    return list;
}
 

@TargetApi(Build.VERSION_CODES.LOLLIPOP_MR1)
private List<AppEntry> getAppEntriesUsingUsageStats() {
    UsageStatsManager mUsageStatsManager = (UsageStatsManager) context.getSystemService(Context.USAGE_STATS_SERVICE);
    List<UsageStats> usageStatsList = mUsageStatsManager.queryUsageStats(UsageStatsManager.INTERVAL_BEST, searchInterval, System.currentTimeMillis());
    List<AppEntry> entries = new ArrayList<>();

    for(UsageStats usageStats : usageStatsList) {
        AppEntry newEntry = new AppEntry(
                usageStats.getPackageName(),
                null,
                null,
                null,
                false
        );

        newEntry.setTotalTimeInForeground(usageStats.getTotalTimeInForeground());
        newEntry.setLastTimeUsed(usageStats.getLastTimeUsed());
        entries.add(newEntry);
    }

    return entries;
}
 

@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public String getForegroundApp(final Context context) {
    if(!Utils.hasUsageStatsPermission(context))
        return null;

    String foregroundApp = null;

    UsageStatsManager mUsageStatsManager = (UsageStatsManager) context.getSystemService(Service.USAGE_STATS_SERVICE);
    long time = System.currentTimeMillis();

    UsageEvents usageEvents = mUsageStatsManager.queryEvents(time - 1000 * 3600, time);
    UsageEvents.Event event = new UsageEvents.Event();
    while (usageEvents.hasNextEvent()) {
        usageEvents.getNextEvent(event);
        if(event.getEventType() == UsageEvents.Event.MOVE_TO_FOREGROUND) {
            foregroundApp = event.getPackageName();
        }
    }

    return foregroundApp ;
}
 

@Override
public boolean isGoRunning() {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP_MR1) {
        UsageStatsManager usm = (UsageStatsManager) getSystemService(USAGE_STATS_SERVICE);
        long time = System.currentTimeMillis();
        List<UsageStats> appList = usm.queryUsageStats(UsageStatsManager.INTERVAL_DAILY, time - REFRESH_INTERVAL * REFRESH_INTERVAL, time);
        if (appList != null && appList.size() > 0) {
            SortedMap<Long, UsageStats> mySortedMap = new TreeMap<>();
            for (UsageStats usageStats : appList) {
                mySortedMap.put(usageStats.getLastTimeUsed(), usageStats);
            }
            if (!mySortedMap.isEmpty()) {
                String currentAppName = mySortedMap.get(mySortedMap.lastKey()).getPackageName();
                return (currentAppName.equals("com.android.systemui") || currentAppName.equals("com.tomer.poke.notifier") || currentAppName.equals(getPackageName())) ? isGoOpen : currentAppName.equals(Constants.GOPackageName);
            }
        }
    } else {
        ActivityManager am = (ActivityManager) getBaseContext().getSystemService(ACTIVITY_SERVICE);
        return am.getRunningTasks(1).get(0).topActivity.getPackageName().equals(Constants.GOPackageName);
    }
    return isGoOpen;
}
 

/**
 * get current task top app package name
 * @param context
 * @param am
 * @return the top app package name
 */
public static String getTaskTopAppPackageName(Context context, ActivityManager am) {
    String packageName = "";
    // if the sdk >= 21. It can only use getRunningAppProcesses to get task top package name
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
        UsageStatsManager usage = (UsageStatsManager)context.getSystemService(Context.USAGE_STATS_SERVICE);
        long time = System.currentTimeMillis();
        List<UsageStats> stats = usage.queryUsageStats(UsageStatsManager.INTERVAL_DAILY, time - 1000 * 10, time);
        if (stats != null) {
            SortedMap<Long, UsageStats> runningTask = new TreeMap<Long,UsageStats>();
            for (UsageStats usageStats : stats) {
                runningTask.put(usageStats.getLastTimeUsed(), usageStats);
            }
            if (runningTask.isEmpty()) {
                return null;
            }
            packageName =  runningTask.get(runningTask.lastKey()).getPackageName();
        }
    } else {// if sdk <= 20, can use getRunningTasks
        List<ActivityManager.RunningTaskInfo> infos = am.getRunningTasks(1);
        packageName = infos.get(0).topActivity.getPackageName();
    }
    return packageName;
}
 

@TargetApi(Build.VERSION_CODES.LOLLIPOP_MR1)
private String getTopActivityAfterLM() {
    try {
        UsageStatsManager usageStatsManager = (UsageStatsManager) getSystemService(Context.USAGE_STATS_SERVICE);
        long milliSecs = 60 * 1000;
        Date date = new Date();
        List<UsageStats> queryUsageStats = usageStatsManager.queryUsageStats(UsageStatsManager.INTERVAL_DAILY, date.getTime() - milliSecs, date.getTime());
        if (queryUsageStats.size() > 0) {
            return null;
        }
        long recentTime = 0;
        String recentPkg = "";
        for (int i = 0; i < queryUsageStats.size(); i++) {
            UsageStats stats = queryUsageStats.get(i);
            if (stats.getLastTimeStamp() > recentTime) {
                recentTime = stats.getLastTimeStamp();
                recentPkg = stats.getPackageName();
            }
        }
        return recentPkg;
    } catch (Exception e) {
        e.printStackTrace();
    }
    return "";
}
 

@SuppressWarnings("ResourceType")
public static void getStats(Context context){
    UsageStatsManager usm = (UsageStatsManager) context.getSystemService("usagestats");
    int interval = UsageStatsManager.INTERVAL_YEARLY;
    Calendar calendar = Calendar.getInstance();
    long endTime = calendar.getTimeInMillis();
    calendar.add(Calendar.YEAR, -1);
    long startTime = calendar.getTimeInMillis();

    Log.d(TAG, "Range start:" + dateFormat.format(startTime) );
    Log.d(TAG, "Range end:" + dateFormat.format(endTime));

    UsageEvents uEvents = usm.queryEvents(startTime,endTime);
    while (uEvents.hasNextEvent()){
        UsageEvents.Event e = new UsageEvents.Event();
        uEvents.getNextEvent(e);

        if (e != null){
            Log.d(TAG, "Event: " + e.getPackageName() + "\t" +  e.getTimeStamp());
        }
    }
}
 

@Override
public @NonNull CharSequence getContent(@NonNull Context context) {
  final UsageStatsManager usageStatsManager = (UsageStatsManager) context.getSystemService(Context.USAGE_STATS_SERVICE);

  if (usageStatsManager == null) {
    return "UsageStatsManager not available";
  }

  BucketInfo info = BucketInfo.getInfo(usageStatsManager, TimeUnit.DAYS.toMillis(3));

  return new StringBuilder().append("Current bucket: ").append(BucketInfo.bucketToString(info.getCurrentBucket())).append('\n')
                            .append("Highest bucket: ").append(BucketInfo.bucketToString(info.getBestBucket())).append('\n')
                            .append("Lowest bucket : ").append(BucketInfo.bucketToString(info.getWorstBucket())).append("\n\n")
                            .append(info.getHistory());
}
 

public static @NonNull BucketInfo getInfo(@NonNull UsageStatsManager usageStatsManager, long overLastDurationMs) {
  StringBuilder stringBuilder = new StringBuilder();

  int currentBucket = usageStatsManager.getAppStandbyBucket();
  int worseBucket   = currentBucket;
  int bestBucket    = currentBucket;

  long              now           = System.currentTimeMillis();
  UsageEvents.Event event         = new UsageEvents.Event();
  UsageEvents       usageEvents   = usageStatsManager.queryEventsForSelf(now - overLastDurationMs, now);

  while (usageEvents.hasNextEvent()) {
    usageEvents.getNextEvent(event);

    if (event.getEventType() == UsageEvents.Event.STANDBY_BUCKET_CHANGED) {
      int appStandbyBucket = event.getAppStandbyBucket();

      stringBuilder.append(new Date(event.getTimeStamp()))
                   .append(": ")
                   .append("Bucket Change: ")
                   .append(bucketToString(appStandbyBucket))
                   .append("\n");

      if (appStandbyBucket > worseBucket) {
        worseBucket = appStandbyBucket;
      }
      if (appStandbyBucket < bestBucket) {
        bestBucket = appStandbyBucket;
      }
    }
  }

  return new BucketInfo(currentBucket, worseBucket, bestBucket, stringBuilder);
}
 

/**
 * Not localized, for logs and debug only.
 */
public static String bucketToString(int bucket) {
  switch (bucket) {
    case UsageStatsManager.STANDBY_BUCKET_ACTIVE:      return "Active";
    case UsageStatsManager.STANDBY_BUCKET_FREQUENT:    return "Frequent";
    case UsageStatsManager.STANDBY_BUCKET_WORKING_SET: return "Working Set";
    case UsageStatsManager.STANDBY_BUCKET_RARE:        return "Rare";
    case                   STANDBY_BUCKET_EXEMPTED:    return "Exempted";
    default:                                           return "Unknown " + bucket;
  }
}
 

public static int standbyBucketToBucketIndex(int bucket) {
    // Normalize AppStandby constants to indices into our bookkeeping
    if (bucket == UsageStatsManager.STANDBY_BUCKET_NEVER) return NEVER_INDEX;
    else if (bucket > UsageStatsManager.STANDBY_BUCKET_FREQUENT) return RARE_INDEX;
    else if (bucket > UsageStatsManager.STANDBY_BUCKET_WORKING_SET) return FREQUENT_INDEX;
    else if (bucket > UsageStatsManager.STANDBY_BUCKET_ACTIVE) return WORKING_INDEX;
    else return ACTIVE_INDEX;
}
 

/**
 * 判断“查看应用使用情况”是否开启
 * @return
 */
private boolean isNoSwitch() {
    long ts = System.currentTimeMillis();
    if(Build.VERSION.SDK_INT >=21){
        //noinspection ResourceType
        usageStatsManager = (UsageStatsManager)getActivity().getApplicationContext().getSystemService("usagestats");
        queryUsageStats = usageStatsManager.queryUsageStats(UsageStatsManager.INTERVAL_BEST, 0, ts);
    }
    if (queryUsageStats == null || queryUsageStats.isEmpty()) {
        return false;
    }
    return true;
}
 

/**
 * 判断“查看应用使用情况”是否开启
 * @return
 */
private boolean isNoSwitch() {
    long ts = System.currentTimeMillis();
    if(Build.VERSION.SDK_INT >=21){
        //noinspection ResourceType
        usageStatsManager = (UsageStatsManager)this.getApplicationContext().getSystemService("usagestats");
        queryUsageStats = usageStatsManager.queryUsageStats(UsageStatsManager.INTERVAL_BEST, 0, ts);
    }
    if (queryUsageStats == null || queryUsageStats.isEmpty()) {
        return false;
    }
    return true;
}
 

private boolean isUserActive(long startTime, long currentTime){
    String TAG = "isUserActive";
    if (currentNotification == 1){
        startTime = startTime - notificationDelay * ONE_MINUTE_MILLIS;
    }

    //#TODO experiment with using a daily interval (make sure it works past midnight)
    List<UsageStats> queryUsageStats = usageStatsManager.queryUsageStats(UsageStatsManager.INTERVAL_WEEKLY, startTime, currentTime);

    UsageStats minUsageStat = null;

    long min = Long.MAX_VALUE;
    for (UsageStats usageStat : queryUsageStats){
        if ((System.currentTimeMillis() - usageStat.getLastTimeStamp() < min) && (usageStat.getTotalTimeInForeground() > ONE_MINUTE_MILLIS) && !usageStat.getPackageName().equals("com.corvettecole.gotosleep")){  //make sure app has been in foreground for more than one minute to filter out background apps
            minUsageStat = usageStat;
            min = System.currentTimeMillis() - usageStat.getLastTimeStamp();
        }
    }

    if (minUsageStat != null) {
        Log.d(TAG, minUsageStat.getPackageName() + " last time used: " + minUsageStat.getLastTimeUsed() + " time in foreground: " + minUsageStat.getTotalTimeInForeground());
        Log.d(TAG, "getLastTimeStamp: " + minUsageStat.getLastTimeStamp() + " getLastUsed: " + minUsageStat.getLastTimeUsed() + " current time: " + System.currentTimeMillis());
        Log.d(TAG, (System.currentTimeMillis() - minUsageStat.getLastTimeUsed() <= userActiveMargin * ONE_MINUTE_MILLIS) + "");
        return System.currentTimeMillis() - minUsageStat.getLastTimeStamp() <= userActiveMargin * ONE_MINUTE_MILLIS;
    } else {
        Log.e(TAG, "minUsageStat was null!");
        Log.e(TAG, queryUsageStats.toString());
        return false;
    }
}
 

public boolean needToSet() {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
        long time = System.currentTimeMillis();
        // We get usage stats for the last 10 seconds
        List<UsageStats> stats = mUsageStatsManager.queryUsageStats(UsageStatsManager.INTERVAL_DAILY, time - 1000 * 60, time);
        return stats.size() == 0;
    } else {
        return false;
    }
}
 

/** Check if permission for usage statistics is required,
 * by fetching usage statistics since the beginning of time
 */
@SuppressWarnings("ResourceType")
public static boolean permissionRequired(Context context) {
    UsageStatsManager usm = (UsageStatsManager) context.getSystemService("usagestats");
    Calendar calendar = Calendar.getInstance();
    long endTime = calendar.getTimeInMillis();
    long startTime = 0;
    List<UsageStats> stats = usm.queryUsageStats(UsageStatsManager.INTERVAL_DAILY, startTime, endTime);
    // If list is empty then permission ios required
    return stats.isEmpty();
}
 

public static String[] getCurrentPackageByManager(Context context) {
    String pkg_name = null;
    String act_name = null;
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP_MR1) {
        UsageStatsManager usageStatsManager = (UsageStatsManager) context.getSystemService(Context.USAGE_STATS_SERVICE);
        if (usageStatsManager != null) {
            long now = System.currentTimeMillis();
            List<UsageStats> stats = usageStatsManager.queryUsageStats(UsageStatsManager.INTERVAL_BEST, now - 6000, now);
            if (stats != null && !stats.isEmpty()) {
                int top = 0;
                for (int last = 0; last < stats.size(); last++) {
                    if (stats.get(last).getLastTimeUsed() > stats.get(top).getLastTimeUsed()) {
                        top = last;
                    }
                }
                pkg_name = stats.get(top).getPackageName();
            }
        }
    } else if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.LOLLIPOP) {
        ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
        @SuppressWarnings("deprecation")
        List list = activityManager.getRunningTasks(1);
        pkg_name = ((ActivityManager.RunningTaskInfo) list.get(0)).topActivity.getPackageName();
        act_name = ((ActivityManager.RunningTaskInfo) list.get(0)).topActivity.getClassName();
    }
    if (pkg_name == null) {
        pkg_name = "";
    }
    if (act_name == null) {
        act_name = pkg_name;
    }
    if (act_name.contains("$")) {
        act_name = act_name.replace("$", ".");
    }
    return new String[]{pkg_name, act_name};
}
 

@VisibleForTesting
void filterForegroundApp(Context context,
                         SharedPreferences pref,
                         long searchInterval,
                         List<String> applicationIdsToRemove) {
    if (pref.getBoolean(PREF_HIDE_FOREGROUND, false)) {
        UsageStatsManager mUsageStatsManager =
                (UsageStatsManager) context.getSystemService(Context.USAGE_STATS_SERVICE);
        UsageEvents events =
                mUsageStatsManager.queryEvents(searchInterval, System.currentTimeMillis());
        UsageEvents.Event eventCache = new UsageEvents.Event();
        String currentForegroundApp = null;

        while (events.hasNextEvent()) {
            events.getNextEvent(eventCache);

            if (eventCache.getEventType() == UsageEvents.Event.MOVE_TO_FOREGROUND) {
                if (!(eventCache.getPackageName().contains(BuildConfig.BASE_APPLICATION_ID)
                        && !eventCache.getClassName().equals(MainActivity.class.getCanonicalName())
                        && !eventCache.getClassName().equals(HomeActivity.class.getCanonicalName())
                        && !eventCache.getClassName().equals(HomeActivityDelegate.class.getCanonicalName())
                        && !eventCache.getClassName().equals(SecondaryHomeActivity.class.getCanonicalName())
                        && !eventCache.getClassName().equals(InvisibleActivityFreeform.class.getCanonicalName()))) {
                    currentForegroundApp = eventCache.getPackageName();
                }
            }
        }

        if (!applicationIdsToRemove.contains(currentForegroundApp)) {
            applicationIdsToRemove.add(currentForegroundApp);
        }
    }
}
 

@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public static boolean isUsageAccess() {
    long ts = System.currentTimeMillis();
    UsageStatsManager usageStatsManager = (UsageStatsManager)
            context.getSystemService(USAGE_STATS_SERVICE);
    List queryUsageStats = usageStatsManager.queryUsageStats(
            UsageStatsManager.INTERVAL_BEST, 0, ts);
    if (queryUsageStats == null || queryUsageStats.isEmpty()) {
        return false;
    }
    return true;
}
 

@TargetApi(Build.VERSION_CODES.LOLLIPOP_MR1)
private String getActivePackages() {
    UsageStatsManager usm = (UsageStatsManager) context.getSystemService(Context.USAGE_STATS_SERVICE);
    long time = System.currentTimeMillis();
    List<UsageStats> appList = usm.queryUsageStats(UsageStatsManager.INTERVAL_DAILY, time - 200 * 200, time);
    if (appList != null && appList.size() > 0) {
        SortedMap<Long, UsageStats> mySortedMap = new TreeMap<>();
        for (UsageStats usageStats : appList) {
            mySortedMap.put(usageStats.getLastTimeUsed(), usageStats);
        }
        return mySortedMap.get(mySortedMap.lastKey()).getPackageName();
    }
    return context.getPackageName();
}
 

/**
 * 方法4：通过使用UsageStatsManager获取，此方法是ndroid5.0A之后提供的API
 * 必须：
 * 1. 此方法只在android5.0以上有效
 * 2. AndroidManifest中加入此权限<uses-permission xmlns:tools="http://schemas.android.com/tools" android:name="android.permission.PACKAGE_USAGE_STATS"
 * tools:ignore="ProtectedPermissions" />
 * 3. 打开手机设置，点击安全-高级，在有权查看使用情况的应用中，为这个App打上勾
 *
 * @param context     上下文参数
 * @param packageName 需要检查是否位于栈顶的App的包名
 * @return
 */

@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public static boolean queryUsageStats(Context context, String packageName) {
    class RecentUseComparator implements Comparator<UsageStats> {
        @Override
        public int compare(UsageStats lhs, UsageStats rhs) {
            return (lhs.getLastTimeUsed() > rhs.getLastTimeUsed()) ? -1 : (lhs.getLastTimeUsed() == rhs.getLastTimeUsed()) ? 0 : 1;
        }
    }
    RecentUseComparator mRecentComp = new RecentUseComparator();
    long ts = System.currentTimeMillis();
    UsageStatsManager mUsageStatsManager = (UsageStatsManager) context.getSystemService("usagestats");
    List<UsageStats> usageStats = mUsageStatsManager.queryUsageStats(UsageStatsManager.INTERVAL_BEST, ts - 1000 * 10, ts);
    if (usageStats == null || usageStats.size() == 0) {
        if (HavaPermissionForTest(context) == false) {
            Intent intent = new Intent(Settings.ACTION_USAGE_ACCESS_SETTINGS);
            intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
            context.startActivity(intent);
            Toast.makeText(context, "权限不够\n请打开手机设置，点击安全-高级，在有权查看使用情况的应用中，为这个App打上勾", Toast.LENGTH_SHORT).show();
        }
        return false;
    }
    Collections.sort(usageStats, mRecentComp);
    String currentTopPackage = usageStats.get(0).getPackageName();
    if (currentTopPackage.equals(packageName)) {
        return true;
    } else {
        return false;
    }
}