| Methods Summary |
|---|
| public void | cancelLoadingThumbnailsAndIcons(RecentsPanelView caller)
// Only oblige this request if it comes from the current RecentsPanel
// (eg when you rotate, the old RecentsPanel request should be ignored)
if (mRecentsPanel == caller) {
cancelLoadingThumbnailsAndIcons();
}
|
| private void | cancelLoadingThumbnailsAndIcons()
if (mRecentsPanel != null && mRecentsPanel.isShowing()) {
return;
}
if (mTaskLoader != null) {
mTaskLoader.cancel(false);
mTaskLoader = null;
}
if (mThumbnailLoader != null) {
mThumbnailLoader.cancel(false);
mThumbnailLoader = null;
}
mLoadedTasks = null;
if (mRecentsPanel != null) {
mRecentsPanel.onTaskLoadingCancelled();
}
mFirstScreenful = false;
mState = State.CANCELLED;
|
| public void | cancelPreloadingFirstTask()
synchronized(mFirstTaskLock) {
if (mPreloadingFirstTask) {
mCancelPreloadingFirstTask = true;
} else {
clearFirstTask();
}
}
|
| public void | cancelPreloadingRecentTasksList()
cancelLoadingThumbnailsAndIcons();
mHandler.removeCallbacks(mPreloadTasksRunnable);
|
| private void | clearFirstTask()
synchronized (mFirstTaskLock) {
mFirstTask = null;
mFirstTaskLoaded = false;
}
|
| TaskDescription | createTaskDescription(int taskId, int persistentTaskId, android.content.Intent baseIntent, android.content.ComponentName origActivity, java.lang.CharSequence description, int userId)
Intent intent = new Intent(baseIntent);
if (origActivity != null) {
intent.setComponent(origActivity);
}
final PackageManager pm = mContext.getPackageManager();
final IPackageManager ipm = AppGlobals.getPackageManager();
intent.setFlags((intent.getFlags()&~Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED)
| Intent.FLAG_ACTIVITY_NEW_TASK);
ResolveInfo resolveInfo = null;
try {
resolveInfo = ipm.resolveIntent(intent, null, 0, userId);
} catch (RemoteException re) {
}
if (resolveInfo != null) {
final ActivityInfo info = resolveInfo.activityInfo;
final String title = info.loadLabel(pm).toString();
if (title != null && title.length() > 0) {
if (DEBUG) Log.v(TAG, "creating activity desc for id="
+ persistentTaskId + ", label=" + title);
TaskDescription item = new TaskDescription(taskId,
persistentTaskId, resolveInfo, baseIntent, info.packageName,
description, userId);
item.setLabel(title);
return item;
} else {
if (DEBUG) Log.v(TAG, "SKIPPING item " + persistentTaskId);
}
}
return null;
|
| public android.graphics.drawable.Drawable | getDefaultIcon()
return mDefaultIconBackground;
|
| public android.graphics.drawable.Drawable | getDefaultThumbnail()
return mDefaultThumbnailBackground;
|
| public TaskDescription | getFirstTask()
while(true) {
synchronized(mFirstTaskLock) {
if (mFirstTaskLoaded) {
return mFirstTask;
} else if (!mFirstTaskLoaded && !mPreloadingFirstTask) {
mFirstTask = loadFirstTask();
mFirstTaskLoaded = true;
return mFirstTask;
}
}
try {
Thread.sleep(3);
} catch (InterruptedException e) {
}
}
|
| android.graphics.drawable.Drawable | getFullResDefaultActivityIcon()
return getFullResIcon(Resources.getSystem(),
com.android.internal.R.mipmap.sym_def_app_icon);
|
| android.graphics.drawable.Drawable | getFullResIcon(android.content.res.Resources resources, int iconId)
try {
return resources.getDrawableForDensity(iconId, mIconDpi);
} catch (Resources.NotFoundException e) {
return getFullResDefaultActivityIcon();
}
|
| private android.graphics.drawable.Drawable | getFullResIcon(android.content.pm.ResolveInfo info, android.content.pm.PackageManager packageManager)
Resources resources;
try {
resources = packageManager.getResourcesForApplication(
info.activityInfo.applicationInfo);
} catch (PackageManager.NameNotFoundException e) {
resources = null;
}
if (resources != null) {
int iconId = info.activityInfo.getIconResource();
if (iconId != 0) {
return getFullResIcon(resources, iconId);
}
}
return getFullResDefaultActivityIcon();
|
| public static com.android.systemui.recent.RecentTasksLoader | getInstance(android.content.Context context)
if (sInstance == null) {
sInstance = new RecentTasksLoader(context);
}
return sInstance;
|
| public java.util.ArrayList | getLoadedTasks()
return mLoadedTasks;
|
| private boolean | isCurrentHomeActivity(android.content.ComponentName component, android.content.pm.ActivityInfo homeInfo)
if (homeInfo == null) {
final PackageManager pm = mContext.getPackageManager();
homeInfo = new Intent(Intent.ACTION_MAIN).addCategory(Intent.CATEGORY_HOME)
.resolveActivityInfo(pm, 0);
}
return homeInfo != null
&& homeInfo.packageName.equals(component.getPackageName())
&& homeInfo.name.equals(component.getClassName());
|
| public boolean | isFirstScreenful()
return mFirstScreenful;
|
| public TaskDescription | loadFirstTask()
final ActivityManager am = (ActivityManager) mContext.getSystemService(Context.ACTIVITY_SERVICE);
final List<ActivityManager.RecentTaskInfo> recentTasks = am.getRecentTasksForUser(1,
ActivityManager.RECENT_IGNORE_UNAVAILABLE | ActivityManager.RECENT_INCLUDE_PROFILES,
UserHandle.CURRENT.getIdentifier());
TaskDescription item = null;
if (recentTasks.size() > 0) {
ActivityManager.RecentTaskInfo recentInfo = recentTasks.get(0);
Intent intent = new Intent(recentInfo.baseIntent);
if (recentInfo.origActivity != null) {
intent.setComponent(recentInfo.origActivity);
}
// Don't load the current home activity.
if (isCurrentHomeActivity(intent.getComponent(), null)) {
return null;
}
// Don't load ourselves
if (intent.getComponent().getPackageName().equals(mContext.getPackageName())) {
return null;
}
item = createTaskDescription(recentInfo.id,
recentInfo.persistentId, recentInfo.baseIntent,
recentInfo.origActivity, recentInfo.description,
recentInfo.userId);
if (item != null) {
loadThumbnailAndIcon(item);
}
return item;
}
return null;
|
| public void | loadTasksInBackground()
loadTasksInBackground(false);
|
| public void | loadTasksInBackground(boolean zeroeth)
if (mState != State.CANCELLED) {
return;
}
mState = State.LOADING;
mFirstScreenful = true;
final LinkedBlockingQueue<TaskDescription> tasksWaitingForThumbnails =
new LinkedBlockingQueue<TaskDescription>();
mTaskLoader = new AsyncTask<Void, ArrayList<TaskDescription>, Void>() {
@Override
protected void onProgressUpdate(ArrayList<TaskDescription>... values) {
if (!isCancelled()) {
ArrayList<TaskDescription> newTasks = values[0];
// do a callback to RecentsPanelView to let it know we have more values
// how do we let it know we're all done? just always call back twice
if (mRecentsPanel != null) {
mRecentsPanel.onTasksLoaded(newTasks, mFirstScreenful);
}
if (mLoadedTasks == null) {
mLoadedTasks = new ArrayList<TaskDescription>();
}
mLoadedTasks.addAll(newTasks);
mFirstScreenful = false;
}
}
@Override
protected Void doInBackground(Void... params) {
// We load in two stages: first, we update progress with just the first screenful
// of items. Then, we update with the rest of the items
final int origPri = Process.getThreadPriority(Process.myTid());
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
final PackageManager pm = mContext.getPackageManager();
final ActivityManager am = (ActivityManager)
mContext.getSystemService(Context.ACTIVITY_SERVICE);
final List<ActivityManager.RecentTaskInfo> recentTasks =
am.getRecentTasks(MAX_TASKS, ActivityManager.RECENT_IGNORE_UNAVAILABLE
| ActivityManager.RECENT_INCLUDE_PROFILES);
int numTasks = recentTasks.size();
ActivityInfo homeInfo = new Intent(Intent.ACTION_MAIN)
.addCategory(Intent.CATEGORY_HOME).resolveActivityInfo(pm, 0);
boolean firstScreenful = true;
ArrayList<TaskDescription> tasks = new ArrayList<TaskDescription>();
// skip the first task - assume it's either the home screen or the current activity.
final int first = 0;
for (int i = first, index = 0; i < numTasks && (index < MAX_TASKS); ++i) {
if (isCancelled()) {
break;
}
final ActivityManager.RecentTaskInfo recentInfo = recentTasks.get(i);
Intent intent = new Intent(recentInfo.baseIntent);
if (recentInfo.origActivity != null) {
intent.setComponent(recentInfo.origActivity);
}
// Don't load the current home activity.
if (isCurrentHomeActivity(intent.getComponent(), homeInfo)) {
continue;
}
// Don't load ourselves
if (intent.getComponent().getPackageName().equals(mContext.getPackageName())) {
continue;
}
TaskDescription item = createTaskDescription(recentInfo.id,
recentInfo.persistentId, recentInfo.baseIntent,
recentInfo.origActivity, recentInfo.description,
recentInfo.userId);
if (item != null) {
while (true) {
try {
tasksWaitingForThumbnails.put(item);
break;
} catch (InterruptedException e) {
}
}
tasks.add(item);
if (firstScreenful && tasks.size() == mNumTasksInFirstScreenful) {
publishProgress(tasks);
tasks = new ArrayList<TaskDescription>();
firstScreenful = false;
//break;
}
++index;
}
}
if (!isCancelled()) {
publishProgress(tasks);
if (firstScreenful) {
// always should publish two updates
publishProgress(new ArrayList<TaskDescription>());
}
}
while (true) {
try {
tasksWaitingForThumbnails.put(new TaskDescription());
break;
} catch (InterruptedException e) {
}
}
Process.setThreadPriority(origPri);
return null;
}
};
mTaskLoader.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
loadThumbnailsAndIconsInBackground(tasksWaitingForThumbnails);
|
| void | loadThumbnailAndIcon(TaskDescription td)
final ActivityManager am = (ActivityManager)
mContext.getSystemService(Context.ACTIVITY_SERVICE);
final PackageManager pm = mContext.getPackageManager();
final Bitmap thumbnail = SystemServicesProxy.getThumbnail(am, td.persistentTaskId);
Drawable icon = getFullResIcon(td.resolveInfo, pm);
if (td.userId != UserHandle.myUserId()) {
// Need to badge the icon
icon = mContext.getPackageManager().getUserBadgedIcon(icon, new UserHandle(td.userId));
}
if (DEBUG) Log.v(TAG, "Loaded bitmap for task "
+ td + ": " + thumbnail);
synchronized (td) {
if (thumbnail != null) {
td.setThumbnail(new BitmapDrawable(mContext.getResources(), thumbnail));
} else {
td.setThumbnail(mDefaultThumbnailBackground);
}
if (icon != null) {
td.setIcon(icon);
}
td.setLoaded(true);
}
|
| private void | loadThumbnailsAndIconsInBackground(java.util.concurrent.BlockingQueue tasksWaitingForThumbnails)
// continually read items from tasksWaitingForThumbnails and load
// thumbnails and icons for them. finish thread when cancelled or there
// is a null item in tasksWaitingForThumbnails
mThumbnailLoader = new AsyncTask<Void, TaskDescription, Void>() {
@Override
protected void onProgressUpdate(TaskDescription... values) {
if (!isCancelled()) {
TaskDescription td = values[0];
if (td.isNull()) { // end sentinel
mState = State.LOADED;
} else {
if (mRecentsPanel != null) {
mRecentsPanel.onTaskThumbnailLoaded(td);
}
}
}
}
@Override
protected Void doInBackground(Void... params) {
final int origPri = Process.getThreadPriority(Process.myTid());
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
while (true) {
if (isCancelled()) {
break;
}
TaskDescription td = null;
while (td == null) {
try {
td = tasksWaitingForThumbnails.take();
} catch (InterruptedException e) {
}
}
if (td.isNull()) { // end sentinel
publishProgress(td);
break;
}
loadThumbnailAndIcon(td);
publishProgress(td);
}
Process.setThreadPriority(origPri);
return null;
}
};
mThumbnailLoader.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
|
| public boolean | onTouch(android.view.View v, android.view.MotionEvent ev)
// additional optimization when we have software system buttons - start loading the recent
// tasks on touch down
int action = ev.getAction() & MotionEvent.ACTION_MASK;
if (action == MotionEvent.ACTION_DOWN) {
preloadRecentTasksList();
} else if (action == MotionEvent.ACTION_CANCEL) {
cancelPreloadingRecentTasksList();
} else if (action == MotionEvent.ACTION_UP) {
// Remove the preloader if we haven't called it yet
mHandler.removeCallbacks(mPreloadTasksRunnable);
if (!v.isPressed()) {
cancelLoadingThumbnailsAndIcons();
}
}
return false;
|
| public void | preloadFirstTask()
Thread bgLoad = new Thread() {
public void run() {
TaskDescription first = loadFirstTask();
synchronized(mFirstTaskLock) {
if (mCancelPreloadingFirstTask) {
clearFirstTask();
} else {
mFirstTask = first;
mFirstTaskLoaded = true;
}
mPreloadingFirstTask = false;
}
}
};
synchronized(mFirstTaskLock) {
if (!mPreloadingFirstTask) {
clearFirstTask();
mPreloadingFirstTask = true;
bgLoad.start();
}
}
|
| public void | preloadRecentTasksList()
mHandler.post(mPreloadTasksRunnable);
|
| public void | remove(TaskDescription td)
mLoadedTasks.remove(td);
|
| public void | setRecentsPanel(RecentsPanelView newRecentsPanel, RecentsPanelView caller)
// Only allow clearing mRecentsPanel if the caller is the current recentsPanel
if (newRecentsPanel != null || mRecentsPanel == caller) {
mRecentsPanel = newRecentsPanel;
if (mRecentsPanel != null) {
mNumTasksInFirstScreenful = mRecentsPanel.numItemsInOneScreenful();
}
}
|
