1593 lines
64 KiB
Java
1593 lines
64 KiB
Java
/*
|
|
* Copyright (C) 2006 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.settings;
|
|
|
|
import com.android.settings.R;
|
|
import android.app.ActivityManager;
|
|
import android.app.AlertDialog;
|
|
import android.app.Dialog;
|
|
import android.app.ListActivity;
|
|
import android.app.ProgressDialog;
|
|
import android.content.BroadcastReceiver;
|
|
import android.content.Context;
|
|
import android.content.DialogInterface;
|
|
import android.content.Intent;
|
|
import android.content.IntentFilter;
|
|
import android.content.pm.ApplicationInfo;
|
|
import android.content.pm.IPackageStatsObserver;
|
|
import android.content.pm.PackageManager;
|
|
import android.content.pm.PackageStats;
|
|
import android.content.pm.PackageManager.NameNotFoundException;
|
|
import android.content.res.Configuration;
|
|
import android.content.res.Resources;
|
|
import android.graphics.drawable.Drawable;
|
|
import android.net.Uri;
|
|
import android.os.Bundle;
|
|
import android.os.Handler;
|
|
import android.os.Message;
|
|
import android.os.SystemClock;
|
|
import android.text.format.Formatter;
|
|
import android.util.Config;
|
|
import android.util.Log;
|
|
import android.view.LayoutInflater;
|
|
import android.view.Menu;
|
|
import android.view.MenuItem;
|
|
import android.view.View;
|
|
import android.view.ViewGroup;
|
|
import android.view.Window;
|
|
import android.widget.AdapterView;
|
|
import android.widget.BaseAdapter;
|
|
import android.widget.ImageView;
|
|
import android.widget.ListView;
|
|
import android.widget.TextView;
|
|
import android.widget.AdapterView.OnItemClickListener;
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.Collections;
|
|
import java.util.Comparator;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Set;
|
|
import java.util.TreeMap;
|
|
import java.util.concurrent.CountDownLatch;
|
|
|
|
/**
|
|
* Activity to pick an application that will be used to display installation information and
|
|
* options to uninstall/delete user data for system applications. This activity
|
|
* can be launched through Settings or via the ACTION_MANAGE_PACKAGE_STORAGE
|
|
* intent.
|
|
* Initially a compute in progress message is displayed while the application retrieves
|
|
* the list of application information from the PackageManager. The size information
|
|
* for each package is refreshed to the screen. The resource(app description and
|
|
* icon) information for each package is not available yet, so some default values for size
|
|
* icon and descriptions are used initially. Later the resource information for each
|
|
* application is retrieved and dynamically updated on the screen.
|
|
* A Broadcast receiver registers for package additions or deletions when the activity is
|
|
* in focus. If the user installs or deletes packages when the activity has focus, the receiver
|
|
* gets notified and proceeds to add/delete these packages from the list on the screen.
|
|
* This is an unlikely scenario but could happen. The entire list gets created every time
|
|
* the activity's onStart gets invoked. This is to avoid having the receiver for the entire
|
|
* life cycle of the application.
|
|
* The applications can be sorted either alphabetically or
|
|
* based on size(descending). If this activity gets launched under low memory
|
|
* situations(A low memory notification dispatches intent
|
|
* ACTION_MANAGE_PACKAGE_STORAGE) the list is sorted per size.
|
|
* If the user selects an application, extended info(like size, uninstall/clear data options,
|
|
* permissions info etc.,) is displayed via the InstalledAppDetails activity.
|
|
*/
|
|
public class ManageApplications extends ListActivity implements
|
|
OnItemClickListener, DialogInterface.OnCancelListener,
|
|
DialogInterface.OnClickListener {
|
|
// TAG for this activity
|
|
private static final String TAG = "ManageApplications";
|
|
|
|
// Log information boolean
|
|
private boolean localLOGV = Config.LOGV || false;
|
|
private static final boolean DEBUG_SIZE = false;
|
|
private static final boolean DEBUG_TIME = false;
|
|
|
|
// attributes used as keys when passing values to InstalledAppDetails activity
|
|
public static final String APP_PKG_PREFIX = "com.android.settings.";
|
|
public static final String APP_PKG_NAME = APP_PKG_PREFIX+"ApplicationPkgName";
|
|
public static final String APP_CHG = APP_PKG_PREFIX+"changed";
|
|
|
|
// attribute name used in receiver for tagging names of added/deleted packages
|
|
private static final String ATTR_PKG_NAME="PackageName";
|
|
private static final String ATTR_APP_PKG_STATS="ApplicationPackageStats";
|
|
|
|
// constant value that can be used to check return code from sub activity.
|
|
private static final int INSTALLED_APP_DETAILS = 1;
|
|
|
|
// sort order that can be changed through the menu can be sorted alphabetically
|
|
// or size(descending)
|
|
private static final int MENU_OPTIONS_BASE = 0;
|
|
public static final int SORT_ORDER_ALPHA = MENU_OPTIONS_BASE + 0;
|
|
public static final int SORT_ORDER_SIZE = MENU_OPTIONS_BASE + 1;
|
|
// Filter options used for displayed list of applications
|
|
public static final int FILTER_APPS_ALL = MENU_OPTIONS_BASE + 2;
|
|
public static final int FILTER_APPS_THIRD_PARTY = MENU_OPTIONS_BASE + 3;
|
|
public static final int FILTER_APPS_RUNNING = MENU_OPTIONS_BASE + 4;
|
|
public static final int FILTER_OPTIONS = MENU_OPTIONS_BASE + 5;
|
|
// Alert Dialog presented to user to find out the filter option
|
|
AlertDialog mAlertDlg;
|
|
// sort order
|
|
private int mSortOrder = SORT_ORDER_ALPHA;
|
|
// Filter value
|
|
int mFilterApps = FILTER_APPS_ALL;
|
|
|
|
// Custom Adapter used for managing items in the list
|
|
private AppInfoAdapter mAppInfoAdapter;
|
|
|
|
// messages posted to the handler
|
|
private static final int HANDLER_MESSAGE_BASE = 0;
|
|
private static final int INIT_PKG_INFO = HANDLER_MESSAGE_BASE+1;
|
|
private static final int COMPUTE_PKG_SIZE_DONE = HANDLER_MESSAGE_BASE+2;
|
|
private static final int REMOVE_PKG = HANDLER_MESSAGE_BASE+3;
|
|
private static final int REORDER_LIST = HANDLER_MESSAGE_BASE+4;
|
|
private static final int ADD_PKG_START = HANDLER_MESSAGE_BASE+5;
|
|
private static final int ADD_PKG_DONE = HANDLER_MESSAGE_BASE+6;
|
|
private static final int REFRESH_APP_RESOURCE = HANDLER_MESSAGE_BASE+7;
|
|
private static final int REFRESH_DONE = HANDLER_MESSAGE_BASE+8;
|
|
private static final int NEXT_LOAD_STEP = HANDLER_MESSAGE_BASE+9;
|
|
private static final int COMPUTE_END = HANDLER_MESSAGE_BASE+10;
|
|
|
|
|
|
// observer object used for computing pkg sizes
|
|
private PkgSizeObserver mObserver;
|
|
// local handle to PackageManager
|
|
private PackageManager mPm;
|
|
// Broadcast Receiver object that receives notifications for added/deleted
|
|
// packages
|
|
private PackageIntentReceiver mReceiver;
|
|
// atomic variable used to track if computing pkg sizes is in progress. should be volatile?
|
|
|
|
private boolean mComputeSizes = false;
|
|
// default icon thats used when displaying applications initially before resource info is
|
|
// retrieved
|
|
private Drawable mDefaultAppIcon;
|
|
|
|
// temporary dialog displayed while the application info loads
|
|
private static final int DLG_BASE = 0;
|
|
private static final int DLG_LOADING = DLG_BASE + 1;
|
|
|
|
// Size resource used for packages whose size computation failed for some reason
|
|
private CharSequence mInvalidSizeStr;
|
|
private CharSequence mComputingSizeStr;
|
|
|
|
// map used to store list of added and removed packages. Immutable Boolean
|
|
// variables indicate if a package has been added or removed. If a package is
|
|
// added or deleted multiple times a single entry with the latest operation will
|
|
// be recorded in the map.
|
|
private Map<String, Boolean> mAddRemoveMap;
|
|
|
|
// layout inflater object used to inflate views
|
|
private LayoutInflater mInflater;
|
|
|
|
// invalid size value used initially and also when size retrieval through PackageManager
|
|
// fails for whatever reason
|
|
private static final int SIZE_INVALID = -1;
|
|
|
|
// debug boolean variable to test delays from PackageManager API's
|
|
private boolean DEBUG_PKG_DELAY = false;
|
|
|
|
// Thread to load resources
|
|
ResourceLoaderThread mResourceThread;
|
|
private TaskRunner mSizeComputor;
|
|
|
|
String mCurrentPkgName;
|
|
|
|
//TODO implement a cache system
|
|
private Map<String, AppInfo> mAppPropCache;
|
|
|
|
// empty message displayed when list is empty
|
|
private TextView mEmptyView;
|
|
|
|
// Boolean variables indicating state
|
|
private boolean mLoadLabels = false;
|
|
private boolean mSizesFirst = false;
|
|
// ListView used to display list
|
|
private ListView mListView;
|
|
// State variables used to figure out menu options and also
|
|
// initiate the first computation and loading of resources
|
|
private boolean mJustCreated = true;
|
|
private boolean mFirst = false;
|
|
private long mLoadTimeStart;
|
|
|
|
/*
|
|
* Handler class to handle messages for various operations
|
|
* Most of the operations that effect Application related data
|
|
* are posted as messages to the handler to avoid synchronization
|
|
* when accessing these structures.
|
|
* When the size retrieval gets kicked off for the first time, a COMPUTE_PKG_SIZE_START
|
|
* message is posted to the handler which invokes the getSizeInfo for the pkg at index 0
|
|
* When the PackageManager's asynchronous call back through
|
|
* PkgSizeObserver.onGetStatsCompleted gets invoked, the application resources like
|
|
* label, description, icon etc., is loaded in the same thread and these values are
|
|
* set on the observer. The observer then posts a COMPUTE_PKG_SIZE_DONE message
|
|
* to the handler. This information is updated on the AppInfoAdapter associated with
|
|
* the list view of this activity and size info retrieval is initiated for the next package as
|
|
* indicated by mComputeIndex
|
|
* When a package gets added while the activity has focus, the PkgSizeObserver posts
|
|
* ADD_PKG_START message to the handler. If the computation is not in progress, the size
|
|
* is retrieved for the newly added package through the observer object and the newly
|
|
* installed app info is updated on the screen. If the computation is still in progress
|
|
* the package is added to an internal structure and action deferred till the computation
|
|
* is done for all the packages.
|
|
* When a package gets deleted, REMOVE_PKG is posted to the handler
|
|
* if computation is not in progress(as indicated by
|
|
* mDoneIniting), the package is deleted from the displayed list of apps. If computation is
|
|
* still in progress the package is added to an internal structure and action deferred till
|
|
* the computation is done for all packages.
|
|
* When the sizes of all packages is computed, the newly
|
|
* added or removed packages are processed in order.
|
|
* If the user changes the order in which these applications are viewed by hitting the
|
|
* menu key, REORDER_LIST message is posted to the handler. this sorts the list
|
|
* of items based on the sort order.
|
|
*/
|
|
private Handler mHandler = new Handler() {
|
|
public void handleMessage(Message msg) {
|
|
PackageStats ps;
|
|
ApplicationInfo info;
|
|
Bundle data;
|
|
String pkgName = null;
|
|
AppInfo appInfo;
|
|
data = msg.getData();
|
|
if(data != null) {
|
|
pkgName = data.getString(ATTR_PKG_NAME);
|
|
}
|
|
switch (msg.what) {
|
|
case INIT_PKG_INFO:
|
|
if(localLOGV) Log.i(TAG, "Message INIT_PKG_INFO");
|
|
if (!mJustCreated) {
|
|
// Add or delete newly created packages by comparing lists
|
|
List<ApplicationInfo> newList = getInstalledApps(FILTER_APPS_ALL);
|
|
updateAppList(newList);
|
|
}
|
|
// Retrieve the package list and init some structures
|
|
initAppList(mFilterApps);
|
|
mHandler.sendEmptyMessage(NEXT_LOAD_STEP);
|
|
break;
|
|
case COMPUTE_PKG_SIZE_DONE:
|
|
if(localLOGV) Log.i(TAG, "Message COMPUTE_PKG_SIZE_DONE");
|
|
if(pkgName == null) {
|
|
Log.w(TAG, "Ignoring message");
|
|
break;
|
|
}
|
|
ps = data.getParcelable(ATTR_APP_PKG_STATS);
|
|
if(ps == null) {
|
|
Log.i(TAG, "Invalid package stats for package:"+pkgName);
|
|
} else {
|
|
mAppInfoAdapter.updateAppSize(pkgName, ps);
|
|
}
|
|
break;
|
|
case COMPUTE_END :
|
|
mComputeSizes = true;
|
|
mFirst = true;
|
|
mHandler.sendEmptyMessage(NEXT_LOAD_STEP);
|
|
break;
|
|
case REMOVE_PKG:
|
|
if(localLOGV) Log.i(TAG, "Message REMOVE_PKG");
|
|
if(pkgName == null) {
|
|
Log.w(TAG, "Ignoring message:REMOVE_PKG for null pkgName");
|
|
break;
|
|
}
|
|
if (!mComputeSizes) {
|
|
Boolean currB = mAddRemoveMap.get(pkgName);
|
|
if (currB == null || (currB.equals(Boolean.TRUE))) {
|
|
mAddRemoveMap.put(pkgName, Boolean.FALSE);
|
|
}
|
|
break;
|
|
}
|
|
List<String> pkgList = new ArrayList<String>();
|
|
pkgList.add(pkgName);
|
|
mAppInfoAdapter.removeFromList(pkgList);
|
|
break;
|
|
case REORDER_LIST:
|
|
if(localLOGV) Log.i(TAG, "Message REORDER_LIST");
|
|
int menuOption = msg.arg1;
|
|
if((menuOption == SORT_ORDER_ALPHA) ||
|
|
(menuOption == SORT_ORDER_SIZE)) {
|
|
// Option to sort list
|
|
if (menuOption != mSortOrder) {
|
|
mSortOrder = menuOption;
|
|
if (localLOGV) Log.i(TAG, "Changing sort order to "+mSortOrder);
|
|
mAppInfoAdapter.sortList(mSortOrder);
|
|
}
|
|
} else if(menuOption != mFilterApps) {
|
|
// Option to filter list
|
|
mFilterApps = menuOption;
|
|
boolean ret = mAppInfoAdapter.resetAppList(mFilterApps);
|
|
if(!ret) {
|
|
// Reset cache
|
|
mAppPropCache = null;
|
|
mFilterApps = FILTER_APPS_ALL;
|
|
mHandler.sendEmptyMessage(INIT_PKG_INFO);
|
|
sendMessageToHandler(REORDER_LIST, menuOption);
|
|
}
|
|
}
|
|
break;
|
|
case ADD_PKG_START:
|
|
if(localLOGV) Log.i(TAG, "Message ADD_PKG_START");
|
|
if(pkgName == null) {
|
|
Log.w(TAG, "Ignoring message:ADD_PKG_START for null pkgName");
|
|
break;
|
|
}
|
|
if (!mComputeSizes || !mLoadLabels) {
|
|
Boolean currB = mAddRemoveMap.get(pkgName);
|
|
if (currB == null || (currB.equals(Boolean.FALSE))) {
|
|
mAddRemoveMap.put(pkgName, Boolean.TRUE);
|
|
}
|
|
break;
|
|
}
|
|
try {
|
|
info = mPm.getApplicationInfo(pkgName, 0);
|
|
} catch (NameNotFoundException e) {
|
|
Log.w(TAG, "Couldnt find application info for:"+pkgName);
|
|
break;
|
|
}
|
|
mObserver.invokeGetSizeInfo(info, ADD_PKG_DONE);
|
|
break;
|
|
case ADD_PKG_DONE:
|
|
if(localLOGV) Log.i(TAG, "Message COMPUTE_PKG_SIZE_DONE");
|
|
if(pkgName == null) {
|
|
Log.w(TAG, "Ignoring message:ADD_PKG_START for null pkgName");
|
|
break;
|
|
}
|
|
ps = data.getParcelable(ATTR_APP_PKG_STATS);
|
|
mAppInfoAdapter.addToList(pkgName, ps);
|
|
break;
|
|
case REFRESH_APP_RESOURCE:
|
|
AppInfo aInfo = (AppInfo) msg.obj;
|
|
if(aInfo == null) {
|
|
Log.w(TAG, "Error loading resources");
|
|
} else {
|
|
mAppInfoAdapter.updateAppsResourceInfo(aInfo);
|
|
}
|
|
break;
|
|
case REFRESH_DONE:
|
|
mLoadLabels = true;
|
|
mHandler.sendEmptyMessage(NEXT_LOAD_STEP);
|
|
break;
|
|
case NEXT_LOAD_STEP:
|
|
if (mComputeSizes && mLoadLabels) {
|
|
doneLoadingData();
|
|
// Check for added/removed packages
|
|
Set<String> keys = mAddRemoveMap.keySet();
|
|
for (String key : keys) {
|
|
if (mAddRemoveMap.get(key) == Boolean.TRUE) {
|
|
// Add the package
|
|
updatePackageList(Intent.ACTION_PACKAGE_ADDED, key);
|
|
} else {
|
|
// Remove the package
|
|
updatePackageList(Intent.ACTION_PACKAGE_REMOVED, key);
|
|
}
|
|
}
|
|
mAddRemoveMap.clear();
|
|
} else if (!mComputeSizes && !mLoadLabels) {
|
|
// Either load the package labels or initiate get size info
|
|
if (mSizesFirst) {
|
|
initComputeSizes();
|
|
} else {
|
|
initResourceThread();
|
|
}
|
|
} else {
|
|
// Create list view from the adapter here. Wait till the sort order
|
|
// of list is defined. its either by label or by size. so atleast one of the
|
|
// first steps should be complete before filling the list
|
|
mAppInfoAdapter.sortBaseList(mSortOrder);
|
|
if (mJustCreated) {
|
|
// Set the adapter here.
|
|
mJustCreated = false;
|
|
mListView.setAdapter(mAppInfoAdapter);
|
|
dismissLoadingMsg();
|
|
}
|
|
if (!mComputeSizes) {
|
|
initComputeSizes();
|
|
} else if (!mLoadLabels) {
|
|
initResourceThread();
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
};
|
|
|
|
class SizeObserver extends IPackageStatsObserver.Stub {
|
|
private int mMsgId;
|
|
private CountDownLatch mCount;
|
|
|
|
SizeObserver(int msgId) {
|
|
mMsgId = msgId;
|
|
}
|
|
|
|
public void invokeGetSize(String packageName, CountDownLatch count) {
|
|
mCount = count;
|
|
mPm.getPackageSizeInfo(packageName, this);
|
|
}
|
|
|
|
public void onGetStatsCompleted(PackageStats pStats, boolean pSucceeded) {
|
|
AppInfo appInfo = null;
|
|
Bundle data = new Bundle();
|
|
data.putString(ATTR_PKG_NAME, pStats.packageName);
|
|
if(pSucceeded && pStats != null) {
|
|
if (localLOGV) Log.i(TAG, "onGetStatsCompleted::"+pStats.packageName+", ("+
|
|
pStats.cacheSize+","+
|
|
pStats.codeSize+", "+pStats.dataSize);
|
|
data.putParcelable(ATTR_APP_PKG_STATS, pStats);
|
|
} else {
|
|
Log.w(TAG, "Invalid package stats from PackageManager");
|
|
}
|
|
//post message to Handler
|
|
Message msg = mHandler.obtainMessage(mMsgId, data);
|
|
msg.setData(data);
|
|
mHandler.sendMessage(msg);
|
|
mCount.countDown();
|
|
}
|
|
}
|
|
|
|
class TaskRunner extends Thread {
|
|
private List<ApplicationInfo> mPkgList;
|
|
private SizeObserver mSizeObserver;
|
|
private static final int END_MSG = COMPUTE_END;
|
|
private static final int mMsgId = COMPUTE_PKG_SIZE_DONE;
|
|
volatile boolean abort = false;
|
|
|
|
TaskRunner(List<ApplicationInfo> appList) {
|
|
mPkgList = appList;
|
|
mSizeObserver = new SizeObserver(mMsgId);
|
|
start();
|
|
}
|
|
|
|
public void setAbort() {
|
|
abort = true;
|
|
}
|
|
|
|
public void run() {
|
|
long startTime;
|
|
if (DEBUG_SIZE || DEBUG_TIME) {
|
|
startTime = SystemClock.elapsedRealtime();
|
|
}
|
|
int size = mPkgList.size();
|
|
for (int i = 0; i < size; i++) {
|
|
if (abort) {
|
|
// Exit if abort has been set.
|
|
break;
|
|
}
|
|
CountDownLatch count = new CountDownLatch(1);
|
|
String packageName = mPkgList.get(i).packageName;
|
|
long startPkgTime;
|
|
if (DEBUG_SIZE) {
|
|
startPkgTime = SystemClock.elapsedRealtime();
|
|
}
|
|
mSizeObserver.invokeGetSize(packageName, count);
|
|
try {
|
|
count.await();
|
|
} catch (InterruptedException e) {
|
|
Log.i(TAG, "Failed computing size for pkg : "+packageName);
|
|
}
|
|
if (DEBUG_SIZE) Log.i(TAG, "Took "+(SystemClock.elapsedRealtime() - startPkgTime) +
|
|
" ms to compute size for pkg : "+packageName);
|
|
}
|
|
if (DEBUG_SIZE || DEBUG_TIME) Log.i(TAG, "Took "+ (SystemClock.elapsedRealtime() - startTime)+ " ms to compute resources " );
|
|
mHandler.sendEmptyMessage(END_MSG);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* This method compares the current cache against a new list of
|
|
* installed applications and tries to update the list with add or remove
|
|
* messages.
|
|
*/
|
|
private boolean updateAppList(List<ApplicationInfo> newList) {
|
|
if ((newList == null) || (mAppPropCache == null)) {
|
|
return false;
|
|
}
|
|
Set<String> existingList = new HashSet<String>();
|
|
boolean ret = false;
|
|
// Loop over new list and find out common elements between old and new lists
|
|
for (ApplicationInfo info : newList) {
|
|
String pkgName = info.packageName;
|
|
AppInfo aInfo = mAppPropCache.get(pkgName);
|
|
if (aInfo != null) {
|
|
existingList.add(pkgName);
|
|
} else {
|
|
// New package. update info by refreshing
|
|
if (localLOGV) Log.i(TAG, "New pkg :"+pkgName+" installed when paused");
|
|
updatePackageList(Intent.ACTION_PACKAGE_ADDED, pkgName);
|
|
ret = true;
|
|
}
|
|
}
|
|
// Loop over old list and figure out state entries
|
|
List<String> deletedList = null;
|
|
Set<String> staleList = mAppPropCache.keySet();
|
|
for (String pkgName : staleList) {
|
|
if (!existingList.contains(pkgName)) {
|
|
if (localLOGV) Log.i(TAG, "Pkg :"+pkgName+" deleted when paused");
|
|
if (deletedList == null) {
|
|
deletedList = new ArrayList<String>();
|
|
deletedList.add(pkgName);
|
|
}
|
|
ret = true;
|
|
}
|
|
}
|
|
// Delete right away
|
|
if (deletedList != null) {
|
|
mAppInfoAdapter.removeFromList(deletedList);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
private void doneLoadingData() {
|
|
setProgressBarIndeterminateVisibility(false);
|
|
}
|
|
|
|
List<ApplicationInfo> getInstalledApps(int filterOption) {
|
|
List<ApplicationInfo> installedAppList = mPm.getInstalledApplications(
|
|
PackageManager.GET_UNINSTALLED_PACKAGES);
|
|
if (installedAppList == null) {
|
|
return new ArrayList<ApplicationInfo> ();
|
|
}
|
|
if (filterOption == FILTER_APPS_THIRD_PARTY) {
|
|
List<ApplicationInfo> appList =new ArrayList<ApplicationInfo> ();
|
|
for (ApplicationInfo appInfo : installedAppList) {
|
|
boolean flag = false;
|
|
if ((appInfo.flags & ApplicationInfo.FLAG_UPDATED_SYSTEM_APP) != 0) {
|
|
// Updated system app
|
|
flag = true;
|
|
} else if ((appInfo.flags & ApplicationInfo.FLAG_SYSTEM) == 0) {
|
|
// Non-system app
|
|
flag = true;
|
|
}
|
|
if (flag) {
|
|
appList.add(appInfo);
|
|
}
|
|
}
|
|
return appList;
|
|
} else if (filterOption == FILTER_APPS_RUNNING) {
|
|
List<ApplicationInfo> appList =new ArrayList<ApplicationInfo> ();
|
|
List<ActivityManager.RunningAppProcessInfo> procList = getRunningAppProcessesList();
|
|
if ((procList == null) || (procList.size() == 0)) {
|
|
return appList;
|
|
}
|
|
// Retrieve running processes from ActivityManager
|
|
for (ActivityManager.RunningAppProcessInfo appProcInfo : procList) {
|
|
if ((appProcInfo != null) && (appProcInfo.pkgList != null)){
|
|
int size = appProcInfo.pkgList.length;
|
|
for (int i = 0; i < size; i++) {
|
|
ApplicationInfo appInfo = null;
|
|
try {
|
|
appInfo = mPm.getApplicationInfo(appProcInfo.pkgList[i],
|
|
PackageManager.GET_UNINSTALLED_PACKAGES);
|
|
} catch (NameNotFoundException e) {
|
|
Log.w(TAG, "Error retrieving ApplicationInfo for pkg:"+appProcInfo.pkgList[i]);
|
|
continue;
|
|
}
|
|
if(appInfo != null) {
|
|
appList.add(appInfo);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return appList;
|
|
} else {
|
|
return installedAppList;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Utility method used to figure out list of apps based on filterOption
|
|
* If the framework supports an additional flag to indicate running apps
|
|
* we can get away with some code here.
|
|
*/
|
|
List<ApplicationInfo> getFilteredApps(List<ApplicationInfo> pAppList, int filterOption) {
|
|
List<ApplicationInfo> retList = new ArrayList<ApplicationInfo>();
|
|
if(pAppList == null) {
|
|
return retList;
|
|
}
|
|
if (filterOption == FILTER_APPS_THIRD_PARTY) {
|
|
List<ApplicationInfo> appList =new ArrayList<ApplicationInfo> ();
|
|
for (ApplicationInfo appInfo : pAppList) {
|
|
boolean flag = false;
|
|
if ((appInfo.flags & ApplicationInfo.FLAG_UPDATED_SYSTEM_APP) != 0) {
|
|
// Updated system app
|
|
flag = true;
|
|
} else if ((appInfo.flags & ApplicationInfo.FLAG_SYSTEM) == 0) {
|
|
// Non-system app
|
|
flag = true;
|
|
}
|
|
if (flag) {
|
|
appList.add(appInfo);
|
|
}
|
|
}
|
|
return appList;
|
|
} else if (filterOption == FILTER_APPS_RUNNING) {
|
|
List<ApplicationInfo> appList =new ArrayList<ApplicationInfo> ();
|
|
List<ActivityManager.RunningAppProcessInfo> procList = getRunningAppProcessesList();
|
|
if ((procList == null) || (procList.size() == 0)) {
|
|
return appList;
|
|
}
|
|
// Retrieve running processes from ActivityManager
|
|
HashMap<String, ActivityManager.RunningAppProcessInfo> runningMap =
|
|
new HashMap<String, ActivityManager.RunningAppProcessInfo>();
|
|
for (ActivityManager.RunningAppProcessInfo appProcInfo : procList) {
|
|
if ((appProcInfo != null) && (appProcInfo.pkgList != null)){
|
|
int size = appProcInfo.pkgList.length;
|
|
for (int i = 0; i < size; i++) {
|
|
runningMap.put(appProcInfo.pkgList[i], appProcInfo);
|
|
}
|
|
}
|
|
}
|
|
// Query list to find running processes in current list
|
|
for (ApplicationInfo appInfo : pAppList) {
|
|
if (runningMap.get(appInfo.packageName) != null) {
|
|
appList.add(appInfo);
|
|
}
|
|
}
|
|
return appList;
|
|
} else {
|
|
return pAppList;
|
|
}
|
|
}
|
|
|
|
private List<ActivityManager.RunningAppProcessInfo> getRunningAppProcessesList() {
|
|
ActivityManager am = (ActivityManager)getSystemService(Context.ACTIVITY_SERVICE);
|
|
return am.getRunningAppProcesses();
|
|
}
|
|
|
|
private void initAppList(int filterOption) {
|
|
initAppList(null, filterOption);
|
|
}
|
|
|
|
// some initialization code used when kicking off the size computation
|
|
private void initAppList(List<ApplicationInfo> appList, int filterOption) {
|
|
setProgressBarIndeterminateVisibility(true);
|
|
mComputeSizes = false;
|
|
mLoadLabels = false;
|
|
// Initialize lists
|
|
mAddRemoveMap = new TreeMap<String, Boolean>();
|
|
mAppInfoAdapter.initMapFromList(appList, filterOption);
|
|
}
|
|
|
|
// Utility method to start a thread to read application labels and icons
|
|
private void initResourceThread() {
|
|
if ((mResourceThread != null) && mResourceThread.isAlive()) {
|
|
mResourceThread.setAbort();
|
|
}
|
|
mResourceThread = new ResourceLoaderThread();
|
|
List<ApplicationInfo> appList = mAppInfoAdapter.getBaseAppList();
|
|
if ((appList != null) && (appList.size()) > 0) {
|
|
mResourceThread.loadAllResources(appList);
|
|
}
|
|
}
|
|
|
|
private void initComputeSizes() {
|
|
// Initiate compute package sizes
|
|
if (localLOGV) Log.i(TAG, "Initiating compute sizes for first time");
|
|
if ((mSizeComputor != null) && (mSizeComputor.isAlive())) {
|
|
mSizeComputor.setAbort();
|
|
}
|
|
List<ApplicationInfo> appList = mAppInfoAdapter.getBaseAppList();
|
|
if ((appList != null) && (appList.size()) > 0) {
|
|
mSizeComputor = new TaskRunner(appList);
|
|
} else {
|
|
mComputeSizes = true;
|
|
}
|
|
}
|
|
|
|
private void showEmptyViewIfListEmpty() {
|
|
if (localLOGV) Log.i(TAG, "Checking for empty view");
|
|
if (mAppInfoAdapter.getCount() > 0) {
|
|
mListView.setVisibility(View.VISIBLE);
|
|
mEmptyView.setVisibility(View.GONE);
|
|
} else {
|
|
mListView.setVisibility(View.GONE);
|
|
mEmptyView.setVisibility(View.VISIBLE);
|
|
}
|
|
}
|
|
|
|
// internal structure used to track added and deleted packages when
|
|
// the activity has focus
|
|
class AddRemoveInfo {
|
|
String pkgName;
|
|
boolean add;
|
|
public AddRemoveInfo(String pPkgName, boolean pAdd) {
|
|
pkgName = pPkgName;
|
|
add = pAdd;
|
|
}
|
|
}
|
|
|
|
class ResourceLoaderThread extends Thread {
|
|
List<ApplicationInfo> mAppList;
|
|
volatile boolean abort = false;
|
|
|
|
public void setAbort() {
|
|
abort = true;
|
|
}
|
|
void loadAllResources(List<ApplicationInfo> appList) {
|
|
mAppList = appList;
|
|
start();
|
|
}
|
|
|
|
public void run() {
|
|
long start;
|
|
if (DEBUG_TIME) {
|
|
start = SystemClock.elapsedRealtime();
|
|
}
|
|
int imax;
|
|
if(mAppList == null || (imax = mAppList.size()) <= 0) {
|
|
Log.w(TAG, "Empty or null application list");
|
|
} else {
|
|
for (int i = 0; i < imax; i++) {
|
|
if (abort) {
|
|
return;
|
|
}
|
|
ApplicationInfo appInfo = mAppList.get(i);
|
|
CharSequence appName = appInfo.loadLabel(mPm);
|
|
Message msg = mHandler.obtainMessage(REFRESH_APP_RESOURCE);
|
|
msg.obj = new AppInfo(appInfo.packageName, appName, null);
|
|
mHandler.sendMessage(msg);
|
|
}
|
|
Message doneMsg = mHandler.obtainMessage(REFRESH_DONE);
|
|
mHandler.sendMessage(doneMsg);
|
|
if (DEBUG_TIME) Log.i(TAG, "Took "+(SystemClock.elapsedRealtime()-start)+" ms to load app labels");
|
|
long startIcons;
|
|
if (DEBUG_TIME) {
|
|
startIcons = SystemClock.elapsedRealtime();
|
|
}
|
|
for (int i = (imax-1); i >= 0; i--) {
|
|
if (abort) {
|
|
return;
|
|
}
|
|
ApplicationInfo appInfo = mAppList.get(i);
|
|
Drawable appIcon = appInfo.loadIcon(mPm);
|
|
Message msg = mHandler.obtainMessage(REFRESH_APP_RESOURCE);
|
|
msg.obj = new AppInfo(appInfo.packageName, null, appIcon);
|
|
mHandler.sendMessage(msg);
|
|
}
|
|
if (DEBUG_TIME) Log.i(TAG, "Took "+(SystemClock.elapsedRealtime()-startIcons)+" ms to load app icons");
|
|
}
|
|
if (DEBUG_TIME) Log.i(TAG, "Took "+(SystemClock.elapsedRealtime()-start)+" ms to load app resources");
|
|
}
|
|
}
|
|
|
|
/* Internal class representing an application or packages displayable attributes
|
|
*
|
|
*/
|
|
class AppInfo {
|
|
public String pkgName;
|
|
int index;
|
|
public CharSequence appName;
|
|
public Drawable appIcon;
|
|
public CharSequence appSize;
|
|
public PackageStats appStats;
|
|
|
|
public void refreshIcon(AppInfo pInfo) {
|
|
if (pInfo == null) {
|
|
return;
|
|
}
|
|
if (pInfo.appName != null) {
|
|
appName = pInfo.appName;
|
|
}
|
|
if (pInfo.appIcon != null) {
|
|
appIcon = pInfo.appIcon;
|
|
}
|
|
}
|
|
public AppInfo(String pName, CharSequence aName, Drawable aIcon) {
|
|
index = -1;
|
|
pkgName = pName;
|
|
appName = aName;
|
|
appIcon = aIcon;
|
|
appStats = null;
|
|
appSize = mComputingSizeStr;
|
|
}
|
|
|
|
public AppInfo(String pName, int pIndex, CharSequence aName, Drawable aIcon,
|
|
PackageStats ps) {
|
|
index = pIndex;
|
|
pkgName = pName;
|
|
appName = aName;
|
|
appIcon = aIcon;
|
|
if(ps == null) {
|
|
appSize = mComputingSizeStr;
|
|
} else {
|
|
appStats = ps;
|
|
appSize = getSizeStr();
|
|
}
|
|
}
|
|
public void setSize(PackageStats ps) {
|
|
appStats = ps;
|
|
if (ps != null) {
|
|
appSize = getSizeStr();
|
|
}
|
|
}
|
|
public long getTotalSize() {
|
|
PackageStats ps = appStats;
|
|
if (ps != null) {
|
|
return ps.cacheSize+ps.codeSize+ps.dataSize;
|
|
}
|
|
return SIZE_INVALID;
|
|
}
|
|
|
|
private String getSizeStr() {
|
|
PackageStats ps = appStats;
|
|
String retStr = "";
|
|
// insert total size information into map to display in view
|
|
// at this point its guaranteed that ps is not null. but checking anyway
|
|
if (ps != null) {
|
|
long size = getTotalSize();
|
|
if (size == SIZE_INVALID) {
|
|
return mInvalidSizeStr.toString();
|
|
}
|
|
return Formatter.formatFileSize(ManageApplications.this, size);
|
|
}
|
|
return retStr;
|
|
}
|
|
}
|
|
|
|
// View Holder used when displaying views
|
|
static class AppViewHolder {
|
|
TextView appName;
|
|
ImageView appIcon;
|
|
TextView appSize;
|
|
}
|
|
|
|
/* Custom adapter implementation for the ListView
|
|
* This adapter maintains a map for each displayed application and its properties
|
|
* An index value on each AppInfo object indicates the correct position or index
|
|
* in the list. If the list gets updated dynamically when the user is viewing the list of
|
|
* applications, we need to return the correct index of position. This is done by mapping
|
|
* the getId methods via the package name into the internal maps and indices.
|
|
* The order of applications in the list is mirrored in mAppLocalList
|
|
*/
|
|
class AppInfoAdapter extends BaseAdapter {
|
|
private Map<String, AppInfo> mAppPropMap;
|
|
private List<ApplicationInfo> mAppList;
|
|
private List<ApplicationInfo> mAppLocalList;
|
|
ApplicationInfo.DisplayNameComparator mAlphaComparator;
|
|
AppInfoComparator mSizeComparator;
|
|
|
|
private AppInfo getFromCache(String packageName) {
|
|
if(mAppPropCache == null) {
|
|
return null;
|
|
}
|
|
return mAppPropCache.get(packageName);
|
|
}
|
|
|
|
// Make sure the cache or map contains entries for all elements
|
|
// in appList for a valid sort.
|
|
public void initMapFromList(List<ApplicationInfo> appList, int filterOption) {
|
|
if (appList == null) {
|
|
// Just refresh the list
|
|
appList = mAppList;
|
|
} else {
|
|
mAppList = appList;
|
|
}
|
|
if (mAppPropCache != null) {
|
|
// Retain previous sort order
|
|
int sortOrder = mSortOrder;
|
|
mAppPropMap = mAppPropCache;
|
|
// TODO is this required?
|
|
sortAppList(mAppList, sortOrder);
|
|
} else {
|
|
// Recreate property map
|
|
mAppPropMap = new TreeMap<String, AppInfo>();
|
|
}
|
|
// Re init the comparators
|
|
mAlphaComparator = null;
|
|
mSizeComparator = null;
|
|
|
|
mAppLocalList = getFilteredApps(appList, filterOption);
|
|
int imax = appList.size();
|
|
for (int i = 0; i < imax; i++) {
|
|
ApplicationInfo info = appList.get(i);
|
|
AppInfo aInfo = mAppPropMap.get(info.packageName);
|
|
if(aInfo == null){
|
|
aInfo = new AppInfo(info.packageName, i,
|
|
info.packageName, mDefaultAppIcon, null);
|
|
if (localLOGV) Log.i(TAG, "Creating entry pkg:"+info.packageName+" to map");
|
|
} else {
|
|
aInfo.index = i;
|
|
if (localLOGV) Log.i(TAG, "Adding pkg:"+info.packageName+" to map");
|
|
}
|
|
mAppPropMap.put(info.packageName, aInfo);
|
|
}
|
|
}
|
|
|
|
public AppInfoAdapter(Context c, List<ApplicationInfo> appList) {
|
|
mAppList = appList;
|
|
}
|
|
|
|
public int getCount() {
|
|
return mAppLocalList.size();
|
|
}
|
|
|
|
public Object getItem(int position) {
|
|
return mAppLocalList.get(position);
|
|
}
|
|
|
|
/*
|
|
* This method returns the index of the package position in the application list
|
|
*/
|
|
public int getIndex(String pkgName) {
|
|
if(pkgName == null) {
|
|
Log.w(TAG, "Getting index of null package in List Adapter");
|
|
}
|
|
int imax = mAppLocalList.size();
|
|
ApplicationInfo appInfo;
|
|
for(int i = 0; i < imax; i++) {
|
|
appInfo = mAppLocalList.get(i);
|
|
if(appInfo.packageName.equalsIgnoreCase(pkgName)) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
public ApplicationInfo getApplicationInfo(int position) {
|
|
int imax = mAppLocalList.size();
|
|
if( (position < 0) || (position >= imax)) {
|
|
Log.w(TAG, "Position out of bounds in List Adapter");
|
|
return null;
|
|
}
|
|
return mAppLocalList.get(position);
|
|
}
|
|
|
|
public long getItemId(int position) {
|
|
int imax = mAppLocalList.size();
|
|
if( (position < 0) || (position >= imax)) {
|
|
Log.w(TAG, "Position out of bounds in List Adapter");
|
|
return -1;
|
|
}
|
|
return mAppPropMap.get(mAppLocalList.get(position).packageName).index;
|
|
}
|
|
|
|
public List<ApplicationInfo> getBaseAppList() {
|
|
return mAppList;
|
|
}
|
|
|
|
public View getView(int position, View convertView, ViewGroup parent) {
|
|
if (position >= mAppLocalList.size()) {
|
|
Log.w(TAG, "Invalid view position:"+position+", actual size is:"+mAppLocalList.size());
|
|
return null;
|
|
}
|
|
// A ViewHolder keeps references to children views to avoid unneccessary calls
|
|
// to findViewById() on each row.
|
|
AppViewHolder holder;
|
|
|
|
// When convertView is not null, we can reuse it directly, there is no need
|
|
// to reinflate it. We only inflate a new View when the convertView supplied
|
|
// by ListView is null.
|
|
if (convertView == null) {
|
|
convertView = mInflater.inflate(R.layout.manage_applications_item, null);
|
|
|
|
// Creates a ViewHolder and store references to the two children views
|
|
// we want to bind data to.
|
|
holder = new AppViewHolder();
|
|
holder.appName = (TextView) convertView.findViewById(R.id.app_name);
|
|
holder.appIcon = (ImageView) convertView.findViewById(R.id.app_icon);
|
|
holder.appSize = (TextView) convertView.findViewById(R.id.app_size);
|
|
convertView.setTag(holder);
|
|
} else {
|
|
// Get the ViewHolder back to get fast access to the TextView
|
|
// and the ImageView.
|
|
holder = (AppViewHolder) convertView.getTag();
|
|
}
|
|
|
|
// Bind the data efficiently with the holder
|
|
ApplicationInfo appInfo = mAppLocalList.get(position);
|
|
AppInfo mInfo = mAppPropMap.get(appInfo.packageName);
|
|
if(mInfo != null) {
|
|
if(mInfo.appName != null) {
|
|
holder.appName.setText(mInfo.appName);
|
|
}
|
|
if(mInfo.appIcon != null) {
|
|
holder.appIcon.setImageDrawable(mInfo.appIcon);
|
|
}
|
|
if (mInfo.appSize != null) {
|
|
holder.appSize.setText(mInfo.appSize);
|
|
}
|
|
} else {
|
|
Log.w(TAG, "No info for package:"+appInfo.packageName+" in property map");
|
|
}
|
|
return convertView;
|
|
}
|
|
|
|
private void adjustIndex() {
|
|
int imax = mAppLocalList.size();
|
|
for (int i = 0; i < imax; i++) {
|
|
ApplicationInfo info = mAppLocalList.get(i);
|
|
mAppPropMap.get(info.packageName).index = i;
|
|
}
|
|
}
|
|
|
|
public void sortAppList(List<ApplicationInfo> appList, int sortOrder) {
|
|
Collections.sort(appList, getAppComparator(sortOrder));
|
|
}
|
|
|
|
public void sortBaseList(int sortOrder) {
|
|
if (localLOGV) Log.i(TAG, "Sorting base list based on sortOrder = "+sortOrder);
|
|
sortAppList(mAppList, sortOrder);
|
|
mAppLocalList = getFilteredApps(mAppList, mFilterApps);
|
|
adjustIndex();
|
|
}
|
|
|
|
public void sortList(int sortOrder) {
|
|
if (localLOGV) Log.i(TAG, "sortOrder = "+sortOrder);
|
|
sortAppList(mAppLocalList, sortOrder);
|
|
adjustIndex();
|
|
notifyDataSetChanged();
|
|
}
|
|
|
|
/*
|
|
* Reset the application list associated with this adapter.
|
|
* @param filterOption Sort the list based on this value
|
|
* @param appList the actual application list that is used to reset
|
|
* @return Return a boolean value to indicate inconsistency
|
|
*/
|
|
public boolean resetAppList(int filterOption) {
|
|
// Change application list based on filter option
|
|
mAppLocalList = getFilteredApps(mAppList, filterOption);
|
|
// Check for all properties in map before sorting. Populate values from cache
|
|
for(ApplicationInfo applicationInfo : mAppLocalList) {
|
|
AppInfo appInfo = mAppPropMap.get(applicationInfo.packageName);
|
|
if(appInfo == null) {
|
|
AppInfo rInfo = getFromCache(applicationInfo.packageName);
|
|
if(rInfo == null) {
|
|
// Need to load resources again. Inconsistency somewhere
|
|
return false;
|
|
}
|
|
mAppPropMap.put(applicationInfo.packageName, rInfo);
|
|
}
|
|
}
|
|
if (mAppLocalList.size() > 0) {
|
|
sortList(mSortOrder);
|
|
} else {
|
|
notifyDataSetChanged();
|
|
}
|
|
showEmptyViewIfListEmpty();
|
|
return true;
|
|
}
|
|
|
|
private Comparator<ApplicationInfo> getAppComparator(int sortOrder) {
|
|
if (sortOrder == SORT_ORDER_ALPHA) {
|
|
// Lazy initialization
|
|
if (mAlphaComparator == null) {
|
|
mAlphaComparator = new ApplicationInfo.DisplayNameComparator(mPm);
|
|
}
|
|
return mAlphaComparator;
|
|
}
|
|
// Lazy initialization
|
|
if(mSizeComparator == null) {
|
|
mSizeComparator = new AppInfoComparator(mAppPropMap);
|
|
}
|
|
return mSizeComparator;
|
|
}
|
|
|
|
public boolean updateAppsResourceInfo(AppInfo pInfo) {
|
|
if((pInfo == null) || (pInfo.pkgName == null)) {
|
|
Log.w(TAG, "Null info when refreshing icon in List Adapter");
|
|
return false;
|
|
}
|
|
AppInfo aInfo = mAppPropMap.get(pInfo.pkgName);
|
|
if (aInfo != null) {
|
|
aInfo.refreshIcon(pInfo);
|
|
notifyDataSetChanged();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private boolean shouldBeInList(int filterOption, ApplicationInfo info) {
|
|
// Match filter here
|
|
if (filterOption == FILTER_APPS_RUNNING) {
|
|
List<ApplicationInfo> runningList = getInstalledApps(FILTER_APPS_RUNNING);
|
|
for (ApplicationInfo running : runningList) {
|
|
if (running.packageName.equalsIgnoreCase(info.packageName)) {
|
|
return true;
|
|
}
|
|
}
|
|
} else if (filterOption == FILTER_APPS_THIRD_PARTY) {
|
|
if ((info.flags & ApplicationInfo.FLAG_SYSTEM) == 0) {
|
|
return true;
|
|
} else if ((info.flags & ApplicationInfo.FLAG_UPDATED_SYSTEM_APP) != 0) {
|
|
return true;
|
|
}
|
|
} else {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
* Add a package to the current list.
|
|
* The package is only added to the displayed list
|
|
* based on the filter value. The package is always added to the property map.
|
|
* @param pkgName name of package to be added
|
|
* @param ps PackageStats of new package
|
|
*/
|
|
public void addToList(String pkgName, PackageStats ps) {
|
|
if((pkgName == null) || (ps == null)) {
|
|
if (pkgName == null) {
|
|
Log.w(TAG, "Adding null pkg to List Adapter");
|
|
} else {
|
|
Log.w(TAG, "Adding pkg : "+pkgName+" with invalid PackageStats");
|
|
}
|
|
return;
|
|
}
|
|
boolean notInList = true;
|
|
// Get ApplicationInfo
|
|
ApplicationInfo info = null;
|
|
try {
|
|
info = mPm.getApplicationInfo(pkgName, 0);
|
|
} catch (NameNotFoundException e) {
|
|
Log.w(TAG, "Ignoring non-existent package:"+pkgName);
|
|
return;
|
|
}
|
|
if(info == null) {
|
|
// Nothing to do log error message and return
|
|
Log.i(TAG, "Null ApplicationInfo for package:"+pkgName);
|
|
return;
|
|
}
|
|
// Add entry to local list
|
|
mAppList.add(info);
|
|
// Add entry to map. Note that the index gets adjusted later on based on
|
|
// whether the newly added package is part of displayed list
|
|
mAppPropMap.put(pkgName, new AppInfo(pkgName, -1,
|
|
info.loadLabel(mPm), info.loadIcon(mPm), ps));
|
|
// Add to list
|
|
if (notInList && (shouldBeInList(mFilterApps, info))) {
|
|
// Binary search returns a negative index (ie -index) of the position where
|
|
// this might be inserted.
|
|
int newIdx = Collections.binarySearch(mAppLocalList, info,
|
|
getAppComparator(mSortOrder));
|
|
if(newIdx >= 0) {
|
|
Log.i(TAG, "Strange. Package:"+pkgName+" is not new");
|
|
return;
|
|
}
|
|
// New entry
|
|
newIdx = -newIdx-1;
|
|
mAppLocalList.add(newIdx, info);
|
|
// Adjust index
|
|
adjustIndex();
|
|
notifyDataSetChanged();
|
|
}
|
|
}
|
|
|
|
private void removePkgListBase(List<String> pkgNames) {
|
|
for (String pkg : pkgNames) {
|
|
removePkgBase(pkg);
|
|
}
|
|
}
|
|
|
|
private void removePkgBase(String pkgName) {
|
|
int imax = mAppList.size();
|
|
for (int i = 0; i < imax; i++) {
|
|
ApplicationInfo app = mAppList.get(i);
|
|
if (app.packageName.equalsIgnoreCase(pkgName)) {
|
|
if (localLOGV) Log.i(TAG, "Removing pkg: "+pkgName+" from base list");
|
|
mAppList.remove(i);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void removeFromList(List<String> pkgNames) {
|
|
if(pkgNames == null) {
|
|
Log.w(TAG, "Removing null pkg list from List Adapter");
|
|
return;
|
|
}
|
|
removePkgListBase(pkgNames);
|
|
int imax = mAppLocalList.size();
|
|
boolean found = false;
|
|
ApplicationInfo info;
|
|
int i, k;
|
|
String pkgName;
|
|
int kmax = pkgNames.size();
|
|
if(kmax <= 0) {
|
|
Log.w(TAG, "Removing empty pkg list from List Adapter");
|
|
return;
|
|
}
|
|
int idxArr[] = new int[kmax];
|
|
for (k = 0; k < kmax; k++) {
|
|
idxArr[k] = -1;
|
|
}
|
|
for (i = 0; i < imax; i++) {
|
|
info = mAppLocalList.get(i);
|
|
for (k = 0; k < kmax; k++) {
|
|
pkgName = pkgNames.get(k);
|
|
if (info.packageName.equalsIgnoreCase(pkgName)) {
|
|
idxArr[k] = i;
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
// Sort idxArr
|
|
Arrays.sort(idxArr);
|
|
// remove the packages based on descending indices
|
|
for (k = kmax-1; k >= 0; k--) {
|
|
// Check if package has been found in the list of existing apps first
|
|
if(idxArr[k] == -1) {
|
|
break;
|
|
}
|
|
info = mAppLocalList.get(idxArr[k]);
|
|
mAppLocalList.remove(idxArr[k]);
|
|
mAppPropMap.remove(info.packageName);
|
|
if (localLOGV) Log.i(TAG, "Removed pkg:"+info.packageName+ " from display list");
|
|
}
|
|
if (found) {
|
|
adjustIndex();
|
|
notifyDataSetChanged();
|
|
}
|
|
}
|
|
|
|
public void updateAppSize(String pkgName, PackageStats ps) {
|
|
if(pkgName == null) {
|
|
return;
|
|
}
|
|
AppInfo entry = mAppPropMap.get(pkgName);
|
|
if (entry == null) {
|
|
Log.w(TAG, "Entry for package:"+pkgName+"doesnt exist in map");
|
|
return;
|
|
}
|
|
// Copy the index into the newly updated entry
|
|
entry.setSize(ps);
|
|
notifyDataSetChanged();
|
|
}
|
|
|
|
public PackageStats getAppStats(String pkgName) {
|
|
if(pkgName == null) {
|
|
return null;
|
|
}
|
|
AppInfo entry = mAppPropMap.get(pkgName);
|
|
if (entry == null) {
|
|
return null;
|
|
}
|
|
return entry.appStats;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Utility method to clear messages to Handler
|
|
* We need'nt synchronize on the Handler since posting messages is guaranteed
|
|
* to be thread safe. Even if the other thread that retrieves package sizes
|
|
* posts a message, we do a cursory check of validity on mAppInfoAdapter's applist
|
|
*/
|
|
private void clearMessagesInHandler() {
|
|
mHandler.removeMessages(INIT_PKG_INFO);
|
|
mHandler.removeMessages(COMPUTE_PKG_SIZE_DONE);
|
|
mHandler.removeMessages(REMOVE_PKG);
|
|
mHandler.removeMessages(REORDER_LIST);
|
|
mHandler.removeMessages(ADD_PKG_START);
|
|
mHandler.removeMessages(ADD_PKG_DONE);
|
|
mHandler.removeMessages(REFRESH_APP_RESOURCE);
|
|
mHandler.removeMessages(REFRESH_DONE);
|
|
mHandler.removeMessages(NEXT_LOAD_STEP);
|
|
mHandler.removeMessages(COMPUTE_END);
|
|
}
|
|
|
|
private void sendMessageToHandler(int msgId, int arg1) {
|
|
Message msg = mHandler.obtainMessage(msgId);
|
|
msg.arg1 = arg1;
|
|
mHandler.sendMessage(msg);
|
|
}
|
|
|
|
private void sendMessageToHandler(int msgId, Bundle data) {
|
|
Message msg = mHandler.obtainMessage(msgId);
|
|
msg.setData(data);
|
|
mHandler.sendMessage(msg);
|
|
}
|
|
|
|
private void sendMessageToHandler(int msgId) {
|
|
mHandler.sendEmptyMessage(msgId);
|
|
}
|
|
|
|
/*
|
|
* Stats Observer class used to compute package sizes and retrieve size information
|
|
* PkgSizeOberver is the call back thats used when invoking getPackageSizeInfo on
|
|
* PackageManager. The values in call back onGetStatsCompleted are validated
|
|
* and the specified message is passed to mHandler. The package name
|
|
* and the AppInfo object corresponding to the package name are set on the message
|
|
*/
|
|
class PkgSizeObserver extends IPackageStatsObserver.Stub {
|
|
private ApplicationInfo mAppInfo;
|
|
private int mMsgId;
|
|
public void onGetStatsCompleted(PackageStats pStats, boolean pSucceeded) {
|
|
if(DEBUG_PKG_DELAY) {
|
|
try {
|
|
Thread.sleep(10*1000);
|
|
} catch (InterruptedException e) {
|
|
}
|
|
}
|
|
AppInfo appInfo = null;
|
|
Bundle data = new Bundle();
|
|
data.putString(ATTR_PKG_NAME, mAppInfo.packageName);
|
|
if(pSucceeded && pStats != null) {
|
|
if (localLOGV) Log.i(TAG, "onGetStatsCompleted::"+pStats.packageName+", ("+
|
|
pStats.cacheSize+","+
|
|
pStats.codeSize+", "+pStats.dataSize);
|
|
data.putParcelable(ATTR_APP_PKG_STATS, pStats);
|
|
} else {
|
|
Log.w(TAG, "Invalid package stats from PackageManager");
|
|
}
|
|
//post message to Handler
|
|
Message msg = mHandler.obtainMessage(mMsgId, data);
|
|
msg.setData(data);
|
|
mHandler.sendMessage(msg);
|
|
}
|
|
|
|
public void invokeGetSizeInfo(ApplicationInfo pAppInfo, int msgId) {
|
|
if(pAppInfo == null || pAppInfo.packageName == null) {
|
|
return;
|
|
}
|
|
if(localLOGV) Log.i(TAG, "Invoking getPackageSizeInfo for package:"+
|
|
pAppInfo.packageName);
|
|
mMsgId = msgId;
|
|
mAppInfo = pAppInfo;
|
|
mPm.getPackageSizeInfo(pAppInfo.packageName, this);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Receives notifications when applications are added/removed.
|
|
*/
|
|
private class PackageIntentReceiver extends BroadcastReceiver {
|
|
void registerReceiver() {
|
|
IntentFilter filter = new IntentFilter(Intent.ACTION_PACKAGE_ADDED);
|
|
filter.addAction(Intent.ACTION_PACKAGE_REMOVED);
|
|
filter.addAction(Intent.ACTION_PACKAGE_CHANGED);
|
|
filter.addDataScheme("package");
|
|
ManageApplications.this.registerReceiver(this, filter);
|
|
}
|
|
@Override
|
|
public void onReceive(Context context, Intent intent) {
|
|
String actionStr = intent.getAction();
|
|
Uri data = intent.getData();
|
|
String pkgName = data.getEncodedSchemeSpecificPart();
|
|
if (localLOGV) Log.i(TAG, "action:"+actionStr+", for package:"+pkgName);
|
|
updatePackageList(actionStr, pkgName);
|
|
}
|
|
}
|
|
|
|
private void updatePackageList(String actionStr, String pkgName) {
|
|
// technically we dont have to invoke handler since onReceive is invoked on
|
|
// the main thread but doing it here for better clarity
|
|
if (Intent.ACTION_PACKAGE_ADDED.equalsIgnoreCase(actionStr)) {
|
|
Bundle data = new Bundle();
|
|
data.putString(ATTR_PKG_NAME, pkgName);
|
|
sendMessageToHandler(ADD_PKG_START, data);
|
|
} else if (Intent.ACTION_PACKAGE_REMOVED.equalsIgnoreCase(actionStr)) {
|
|
Bundle data = new Bundle();
|
|
data.putString(ATTR_PKG_NAME, pkgName);
|
|
sendMessageToHandler(REMOVE_PKG, data);
|
|
}
|
|
}
|
|
|
|
|
|
@Override
|
|
protected void onCreate(Bundle savedInstanceState) {
|
|
super.onCreate(savedInstanceState);
|
|
Intent intent = getIntent();
|
|
String action = intent.getAction();
|
|
if (action.equals(Intent.ACTION_MANAGE_PACKAGE_STORAGE)) {
|
|
mSortOrder = SORT_ORDER_SIZE;
|
|
mSizesFirst = true;
|
|
}
|
|
mPm = getPackageManager();
|
|
// initialize some window features
|
|
requestWindowFeature(Window.FEATURE_RIGHT_ICON);
|
|
requestWindowFeature(Window.FEATURE_PROGRESS);
|
|
requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);
|
|
setContentView(R.layout.compute_sizes);
|
|
showLoadingMsg();
|
|
mDefaultAppIcon =Resources.getSystem().getDrawable(
|
|
com.android.internal.R.drawable.sym_def_app_icon);
|
|
mInvalidSizeStr = getText(R.string.invalid_size_value);
|
|
mComputingSizeStr = getText(R.string.computing_size);
|
|
// initialize the inflater
|
|
mInflater = (LayoutInflater)getSystemService(Context.LAYOUT_INFLATER_SERVICE);
|
|
mReceiver = new PackageIntentReceiver();
|
|
mEmptyView = (TextView) findViewById(R.id.empty_view);
|
|
mObserver = new PkgSizeObserver();
|
|
// Create adapter and list view here
|
|
List<ApplicationInfo> appList = getInstalledApps(mSortOrder);
|
|
mAppInfoAdapter = new AppInfoAdapter(this, appList);
|
|
ListView lv= (ListView) findViewById(android.R.id.list);
|
|
lv.setOnItemClickListener(this);
|
|
lv.setSaveEnabled(true);
|
|
lv.setItemsCanFocus(true);
|
|
lv.setOnItemClickListener(this);
|
|
mListView = lv;
|
|
}
|
|
|
|
@Override
|
|
public Dialog onCreateDialog(int id) {
|
|
if (id == DLG_LOADING) {
|
|
ProgressDialog dlg = new ProgressDialog(this);
|
|
dlg.setProgressStyle(ProgressDialog.STYLE_SPINNER);
|
|
dlg.setMessage(getText(R.string.loading));
|
|
dlg.setIndeterminate(true);
|
|
dlg.setOnCancelListener(this);
|
|
return dlg;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
|
|
private void showLoadingMsg() {
|
|
if (DEBUG_TIME) {
|
|
mLoadTimeStart = SystemClock.elapsedRealtime();
|
|
}
|
|
showDialog(DLG_LOADING);
|
|
if(localLOGV) Log.i(TAG, "Displaying Loading message");
|
|
}
|
|
|
|
private void dismissLoadingMsg() {
|
|
if(localLOGV) Log.i(TAG, "Dismissing Loading message");
|
|
dismissDialog(DLG_LOADING);
|
|
if (DEBUG_TIME) Log.i(TAG, "Displayed loading message for "+
|
|
(SystemClock.elapsedRealtime() - mLoadTimeStart));
|
|
}
|
|
|
|
@Override
|
|
public void onStart() {
|
|
super.onStart();
|
|
// register receiver
|
|
mReceiver.registerReceiver();
|
|
sendMessageToHandler(INIT_PKG_INFO);
|
|
}
|
|
|
|
@Override
|
|
public void onStop() {
|
|
super.onStop();
|
|
// Stop the background threads
|
|
if (mResourceThread != null) {
|
|
mResourceThread.setAbort();
|
|
}
|
|
if (mSizeComputor != null) {
|
|
mSizeComputor.setAbort();
|
|
}
|
|
// clear all messages related to application list
|
|
clearMessagesInHandler();
|
|
// register receiver here
|
|
unregisterReceiver(mReceiver);
|
|
mAppPropCache = mAppInfoAdapter.mAppPropMap;
|
|
}
|
|
|
|
// Avoid the restart and pause when orientation changes
|
|
@Override
|
|
public void onConfigurationChanged(Configuration newConfig) {
|
|
super.onConfigurationChanged(newConfig);
|
|
}
|
|
|
|
/*
|
|
* comparator class used to sort AppInfo objects based on size
|
|
*/
|
|
public static class AppInfoComparator implements Comparator<ApplicationInfo> {
|
|
public AppInfoComparator(Map<String, AppInfo> pAppPropMap) {
|
|
mAppPropMap= pAppPropMap;
|
|
}
|
|
|
|
public final int compare(ApplicationInfo a, ApplicationInfo b) {
|
|
AppInfo ainfo = mAppPropMap.get(a.packageName);
|
|
AppInfo binfo = mAppPropMap.get(b.packageName);
|
|
long atotal = ainfo.getTotalSize();
|
|
long btotal = binfo.getTotalSize();
|
|
long ret = atotal - btotal;
|
|
// negate result to sort in descending order
|
|
if (ret < 0) {
|
|
return 1;
|
|
}
|
|
if (ret == 0) {
|
|
return 0;
|
|
}
|
|
return -1;
|
|
}
|
|
private Map<String, AppInfo> mAppPropMap;
|
|
}
|
|
|
|
// utility method used to start sub activity
|
|
private void startApplicationDetailsActivity() {
|
|
// Create intent to start new activity
|
|
Intent intent = new Intent(Intent.ACTION_VIEW);
|
|
intent.setClass(this, InstalledAppDetails.class);
|
|
intent.putExtra(APP_PKG_NAME, mCurrentPkgName);
|
|
// start new activity to display extended information
|
|
startActivityForResult(intent, INSTALLED_APP_DETAILS);
|
|
}
|
|
|
|
@Override
|
|
public boolean onCreateOptionsMenu(Menu menu) {
|
|
menu.add(0, SORT_ORDER_ALPHA, 1, R.string.sort_order_alpha)
|
|
.setIcon(android.R.drawable.ic_menu_sort_alphabetically);
|
|
menu.add(0, SORT_ORDER_SIZE, 2, R.string.sort_order_size)
|
|
.setIcon(android.R.drawable.ic_menu_sort_by_size);
|
|
menu.add(0, FILTER_OPTIONS, 3, R.string.filter)
|
|
.setIcon(R.drawable.ic_menu_filter_settings);
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public boolean onPrepareOptionsMenu(Menu menu) {
|
|
if (mFirst) {
|
|
menu.findItem(SORT_ORDER_ALPHA).setVisible(mSortOrder != SORT_ORDER_ALPHA);
|
|
menu.findItem(SORT_ORDER_SIZE).setVisible(mSortOrder != SORT_ORDER_SIZE);
|
|
menu.findItem(FILTER_OPTIONS).setVisible(true);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public boolean onOptionsItemSelected(MenuItem item) {
|
|
int menuId = item.getItemId();
|
|
if ((menuId == SORT_ORDER_ALPHA) || (menuId == SORT_ORDER_SIZE)) {
|
|
sendMessageToHandler(REORDER_LIST, menuId);
|
|
} else if (menuId == FILTER_OPTIONS) {
|
|
if (mAlertDlg == null) {
|
|
mAlertDlg = new AlertDialog.Builder(this).
|
|
setTitle(R.string.filter_dlg_title).
|
|
setNeutralButton(R.string.cancel, this).
|
|
setSingleChoiceItems(new CharSequence[] {getText(R.string.filter_apps_all),
|
|
getText(R.string.filter_apps_running),
|
|
getText(R.string.filter_apps_third_party)},
|
|
-1, this).
|
|
create();
|
|
}
|
|
mAlertDlg.show();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public void onItemClick(AdapterView<?> parent, View view, int position,
|
|
long id) {
|
|
ApplicationInfo info = (ApplicationInfo)mAppInfoAdapter.getItem(position);
|
|
mCurrentPkgName = info.packageName;
|
|
startApplicationDetailsActivity();
|
|
}
|
|
|
|
// Finish the activity if the user presses the back button to cancel the activity
|
|
public void onCancel(DialogInterface dialog) {
|
|
finish();
|
|
}
|
|
|
|
public void onClick(DialogInterface dialog, int which) {
|
|
int newOption;
|
|
switch (which) {
|
|
// Make sure that values of 0, 1, 2 match options all, running, third_party when
|
|
// created via the AlertDialog.Builder
|
|
case 0:
|
|
newOption = FILTER_APPS_ALL;
|
|
break;
|
|
case 1:
|
|
newOption = FILTER_APPS_RUNNING;
|
|
break;
|
|
case 2:
|
|
newOption = FILTER_APPS_THIRD_PARTY;
|
|
break;
|
|
default:
|
|
return;
|
|
}
|
|
mAlertDlg.dismiss();
|
|
sendMessageToHandler(REORDER_LIST, newOption);
|
|
}
|
|
}
|