Java ActivityManager.RecentTaskInfo方法代码示例

import android.app.ActivityManager; //导入方法依赖的package包/类
/**
 * Refreshes the recently launched applications stacked over the favorites. The number
 * of recents depends on how many favorites are present.
 */
private void bindRecents() {
    final PackageManager manager = getPackageManager();
    final ActivityManager tasksManager = (ActivityManager) getSystemService(ACTIVITY_SERVICE);
    final List<ActivityManager.RecentTaskInfo> recentTasks = tasksManager.getRecentTasks(
            MAX_RECENT_TASKS, 0);

    final int count = recentTasks.size();
    final ArrayList<ApplicationInfo> recents = new ArrayList<ApplicationInfo>();

    for (int i = count - 1; i >= 0; i--) {
        final Intent intent = recentTasks.get(i).baseIntent;

        if (Intent.ACTION_MAIN.equals(intent.getAction()) &&
                !intent.hasCategory(Intent.CATEGORY_HOME)) {

            ApplicationInfo info = getApplicationInfo(manager, intent);
            if (info != null) {
                info.intent = intent;
                if (!mFavorites.contains(info)) {
                    recents.add(info);
                }
            }
        }
    }

    mApplicationsStack.setRecents(recents);
}
 

import android.app.ActivityManager; //导入方法依赖的package包/类
/**
 * App started in VA may be removed in OverView screen, then AMS.removeTask
 * will be invoked, all data struct about the task in AMS are released,
 * while the client's process is still alive. So remove related data in VA
 * as well. A new TaskRecord will be recreated in `onActivityCreated`
 */
private void optimizeTasksLocked() {
    // noinspection deprecation
    ArrayList<ActivityManager.RecentTaskInfo> recentTask = new ArrayList<>(mAM.getRecentTasks(Integer.MAX_VALUE,
            ActivityManager.RECENT_WITH_EXCLUDED | ActivityManager.RECENT_IGNORE_UNAVAILABLE));
    int N = mHistory.size();
    while (N-- > 0) {
        TaskRecord task = mHistory.valueAt(N);
        ListIterator<ActivityManager.RecentTaskInfo> iterator = recentTask.listIterator();
        boolean taskAlive = false;
        while (iterator.hasNext()) {
            ActivityManager.RecentTaskInfo info = iterator.next();
            if (info.id == task.taskId) {
                taskAlive = true;
                iterator.remove();
                break;
            }
        }
        if (!taskAlive) {
            mHistory.removeAt(N);
        }
    }
}
 

import android.app.ActivityManager; //导入方法依赖的package包/类
/**
 * 通过ActivityManager拿到栈顶Activity的ClassName，然后跟列表中的Activity比对，获取栈顶Activity。
 * 注意：这种方式有个很严重的缺陷，如果某个Activity在栈里多次出现将导致判断错误，这时候将返回null。
 * 可靠性相对一般，不会返回错误结果。
 *
 * @param application application
 * @param activities  所有的Activity列表
 * @return 栈顶Activity，获取不到的时候将返回null，不会返回错误结果。
 * @throws ReflectUtils.ReflectException 可能会发生异常，强制要求处理异常情况。
 */
public static Activity getTopActivityByActivityManager(Context application
        , List<Activity> activities) throws ReflectUtils.ReflectException {
    ActivityManager activityManager = (ActivityManager) application
            .getSystemService(Context.ACTIVITY_SERVICE);
    String topActivity = null;
    String packageName = application.getPackageName();
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        List<ActivityManager.AppTask> appTasks = activityManager.getAppTasks();
        for (int i = 0, size = appTasks.size(); i < size; i++) {
            ActivityManager.RecentTaskInfo taskInfo = appTasks.get(size - 1 - i).getTaskInfo();
            if (packageName.equals(taskInfo.baseActivity.getPackageName())) {
                topActivity = taskInfo.topActivity.getClassName();
            }
        }
    }
    if (TextUtils.isEmpty(topActivity)) {
        Log.i(TAG, "尝试通过getTopActivityByActivityManager获取Activity失败");
        return null;
    }

    boolean check = false;
    Activity result = null;
    if (activities != null) {
        for (Activity activity : activities) {
            if (topActivity.equals(activity.getClass().getName())) {
                if (check) {
                    // 出现重复Activity，返回null
                    Log.i(TAG, "尝试通过getTopActivityByActivityManager获取Activity失败");
                    return null;
                }
                check = true;
                result = activity;
            }
        }
    }
    if (result == null) {
        Log.w(TAG, "尝试通过getTopActivityByActivityManager获取Activity失败");
    } else {
        Log.i(TAG, "尝试通过getTopActivityByActivityManager获取Activity成功");
    }
    return result;
}
 

import android.app.ActivityManager; //导入方法依赖的package包/类
public static boolean isFreeForm(ActivityManager.RecentTaskInfo taskInfo) {
    return taskInfo.stackId == FREEFORM_WORKSPACE_STACK_ID;
}
 

import android.app.ActivityManager; //导入方法依赖的package包/类
public static long getLastActiveTime(ActivityManager.RecentTaskInfo taskInfo) {
    return taskInfo.lastActiveTime;
}
 

import android.app.ActivityManager; //导入方法依赖的package包/类
/**
   * 核心方法，加载最近启动的应用程序 注意：这里我们取出的最近任务为 MAX_RECENT_TASKS +
   * 1个，因为有可能最近任务中包好Launcher2。 这样可以保证我们展示出来的 最近任务 为 MAX_RECENT_TASKS 个
   * 通过以下步骤，可以获得近期任务列表，并将其存放在了appInfos这个list中，接下来就是展示这个list的工作了。
   */
  public static List<HashMap<String, Object>> reloadButtons(Context context, int appNumber) {
      List<HashMap<String, Object>> appInfos = new ArrayList<>();
      int MAX_RECENT_TASKS = appNumber; // allow for some discards
      int repeatCount = appNumber;// 保证上面两个值相等,设定存放的程序个数

/* 每次加载必须清空list中的内容 */
      appInfos.removeAll(appInfos);

      // 得到包管理器和activity管理器
      final PackageManager pm = context.getPackageManager();
      final ActivityManager am = (ActivityManager) context
              .getSystemService(Context.ACTIVITY_SERVICE);

      // 从ActivityManager中取出用户最近launch过的 MAX_RECENT_TASKS + 1 个，以从早到晚的时间排序，
      // 注意这个 0x0002,它的值在launcher中是用ActivityManager.RECENT_IGNORE_UNAVAILABLE
      // 但是这是一个隐藏域，因此我把它的值直接拷贝到这里
      try {
          final List<ActivityManager.RecentTaskInfo> recentTasks = am
                  .getRecentTasks(MAX_RECENT_TASKS + 1, 0x0002);


          // 这个activity的信息是我们的launcher
          ActivityInfo homeInfo = new Intent(Intent.ACTION_MAIN).addCategory(
                  Intent.CATEGORY_HOME).resolveActivityInfo(pm, 0);
          int numTasks = recentTasks.size();
          for (int i = 0; i < numTasks && (i < MAX_RECENT_TASKS); i++) {
              HashMap<String, Object> singleAppInfo = new HashMap<String, Object>();// 当个启动过的应用程序的信息
              final ActivityManager.RecentTaskInfo info = recentTasks.get(i);

              Intent intent = new Intent(info.baseIntent);
              if (info.origActivity != null) {
                  intent.setComponent(info.origActivity);
              }
              /**
               * 如果找到是launcher，直接continue，后面的appInfos.add操作就不会发生了
               */
              if (homeInfo != null) {
                  if (homeInfo.packageName.equals(intent.getComponent()
                          .getPackageName())
                          && homeInfo.name.equals(intent.getComponent()
                          .getClassName())) {
                      MAX_RECENT_TASKS = MAX_RECENT_TASKS + 1;
                      continue;
                  }
              }
              // 设置intent的启动方式为 创建新task()【并不一定会创建】
              intent.setFlags((intent.getFlags() & ~Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED)
                      | Intent.FLAG_ACTIVITY_NEW_TASK);
              // 获取指定应用程序activity的信息(按我的理解是：某一个应用程序的最后一个在前台出现过的activity。)
              final ResolveInfo resolveInfo = pm.resolveActivity(intent, 0);
              if (resolveInfo != null) {
                  final ActivityInfo activityInfo = resolveInfo.activityInfo;
                  final String title = activityInfo.loadLabel(pm).toString();
                  final int uid = activityInfo.applicationInfo.uid;
                  Drawable icon = activityInfo.loadIcon(pm);

                  if (title != null && title.length() > 0 && icon != null) {
                      singleAppInfo.put("title", title);
                      singleAppInfo.put("icon", icon);
                      singleAppInfo.put("tag", intent);
                      singleAppInfo.put("uid", uid);
                      singleAppInfo.put("packageName", activityInfo.packageName);
                      appInfos.add(singleAppInfo);
                  }
              }
          }
          return appInfos;
      } catch (Exception e) {
          e.printStackTrace();
          Log.d("mmm", e.getMessage());
          return null;
      }
  }
 

import android.app.ActivityManager; //导入方法依赖的package包/类
/**
   * 核心方法，加载最近启动的应用程序 注意：这里我们取出的最近任务为 MAX_RECENT_TASKS +
   * 1个，因为有可能最近任务中包好Launcher2。 这样可以保证我们展示出来的 最近任务 为 MAX_RECENT_TASKS 个
   * 通过以下步骤，可以获得近期任务列表，并将其存放在了appInfos这个list中，接下来就是展示这个list的工作了。
   */
  public static void reloadButtons(Activity activity, List<HashMap<String, Object>> appInfos, int appNumber) {
      int MAX_RECENT_TASKS = appNumber; // allow for some discards
      int repeatCount = appNumber;// 保证上面两个值相等,设定存放的程序个数

/* 每次加载必须清空list中的内容 */
      appInfos.removeAll(appInfos);

      // 得到包管理器和activity管理器
      final Context context = activity.getApplication();
      final PackageManager pm = context.getPackageManager();
      final ActivityManager am = (ActivityManager) context
              .getSystemService(Context.ACTIVITY_SERVICE);

      // 从ActivityManager中取出用户最近launch过的 MAX_RECENT_TASKS + 1 个，以从早到晚的时间排序，
      // 注意这个 0x0002,它的值在launcher中是用ActivityManager.RECENT_IGNORE_UNAVAILABLE
      // 但是这是一个隐藏域，因此我把它的值直接拷贝到这里
      try {
          final List<ActivityManager.RecentTaskInfo> recentTasks = am
                  .getRecentTasks(MAX_RECENT_TASKS + 1, 0x0002);


          // 这个activity的信息是我们的launcher
          ActivityInfo homeInfo = new Intent(Intent.ACTION_MAIN).addCategory(
                  Intent.CATEGORY_HOME).resolveActivityInfo(pm, 0);
          int numTasks = recentTasks.size();
          for (int i = 0; i < numTasks && (i < MAX_RECENT_TASKS); i++) {
              HashMap<String, Object> singleAppInfo = new HashMap<String, Object>();// 当个启动过的应用程序的信息
              final ActivityManager.RecentTaskInfo info = recentTasks.get(i);

              Intent intent = new Intent(info.baseIntent);
              if (info.origActivity != null) {
                  intent.setComponent(info.origActivity);
              }
              /**
               * 如果找到是launcher，直接continue，后面的appInfos.add操作就不会发生了
               */
              if (homeInfo != null) {
                  if (homeInfo.packageName.equals(intent.getComponent()
                          .getPackageName())
                          && homeInfo.name.equals(intent.getComponent()
                          .getClassName())) {
                      MAX_RECENT_TASKS = MAX_RECENT_TASKS + 1;
                      continue;
                  }
              }
              // 设置intent的启动方式为 创建新task()【并不一定会创建】
              intent.setFlags((intent.getFlags() & ~Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED)
                      | Intent.FLAG_ACTIVITY_NEW_TASK);
              // 获取指定应用程序activity的信息(按我的理解是：某一个应用程序的最后一个在前台出现过的activity。)
              final ResolveInfo resolveInfo = pm.resolveActivity(intent, 0);
              if (resolveInfo != null) {
                  final ActivityInfo activityInfo = resolveInfo.activityInfo;
                  final String title = activityInfo.loadLabel(pm).toString();
                  Drawable icon = activityInfo.loadIcon(pm);

                  if (title != null && title.length() > 0 && icon != null) {
                      singleAppInfo.put("title", title);
                      singleAppInfo.put("icon", icon);
                      singleAppInfo.put("tag", intent);
                      singleAppInfo.put("packageName", activityInfo.packageName);
                      appInfos.add(singleAppInfo);
                  }
              }
          }
      } catch (Exception e) {
          e.printStackTrace();
          return;
      }
      MAX_RECENT_TASKS = repeatCount;
  }