656 lines
27 KiB
Java
656 lines
27 KiB
Java
|
|
|
|
/**
|
|
* Copyright (C) 2007 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.Activity;
|
|
import android.app.ActivityManager;
|
|
import android.app.AlertDialog;
|
|
import android.app.Dialog;
|
|
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.IPackageDataObserver;
|
|
import android.content.pm.IPackageMoveObserver;
|
|
import android.content.pm.IPackageStatsObserver;
|
|
import android.content.pm.PackageInfo;
|
|
import android.content.pm.PackageManager;
|
|
import android.content.pm.PackageParser;
|
|
import android.content.pm.PackageStats;
|
|
import android.content.pm.PackageManager.NameNotFoundException;
|
|
import android.net.Uri;
|
|
import android.os.Bundle;
|
|
import android.os.Handler;
|
|
import android.os.Message;
|
|
import android.os.RemoteException;
|
|
import android.text.format.Formatter;
|
|
import android.util.Log;
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
import android.content.ComponentName;
|
|
import android.view.View;
|
|
import android.widget.AppSecurityPermissions;
|
|
import android.widget.Button;
|
|
import android.widget.ImageView;
|
|
import android.widget.LinearLayout;
|
|
import android.widget.TextView;
|
|
|
|
/**
|
|
* Activity to display application information from Settings. This activity presents
|
|
* extended information associated with a package like code, data, total size, permissions
|
|
* used by the application and also the set of default launchable activities.
|
|
* For system applications, an option to clear user data is displayed only if data size is > 0.
|
|
* System applications that do not want clear user data do not have this option.
|
|
* For non-system applications, there is no option to clear data. Instead there is an option to
|
|
* uninstall the application.
|
|
*/
|
|
public class InstalledAppDetails extends Activity implements View.OnClickListener {
|
|
private static final String TAG="InstalledAppDetails";
|
|
private static final int _UNKNOWN_APP=R.string.unknown;
|
|
private ApplicationInfo mAppInfo;
|
|
private Button mUninstallButton;
|
|
private boolean mUpdatedSysApp = false;
|
|
private Button mActivitiesButton;
|
|
private boolean localLOGV = false;
|
|
private TextView mAppVersion;
|
|
private TextView mTotalSize;
|
|
private TextView mAppSize;
|
|
private TextView mDataSize;
|
|
private PkgSizeObserver mSizeObserver;
|
|
private ClearUserDataObserver mClearDataObserver;
|
|
// Views related to cache info
|
|
private TextView mCacheSize;
|
|
private Button mClearCacheButton;
|
|
private ClearCacheObserver mClearCacheObserver;
|
|
private Button mForceStopButton;
|
|
private Button mClearDataButton;
|
|
private Button mMoveAppButton;
|
|
|
|
PackageStats mSizeInfo;
|
|
private PackageManager mPm;
|
|
private PackageMoveObserver mPackageMoveObserver;
|
|
|
|
//internal constants used in Handler
|
|
private static final int OP_SUCCESSFUL = 1;
|
|
private static final int OP_FAILED = 2;
|
|
private static final int CLEAR_USER_DATA = 1;
|
|
private static final int GET_PKG_SIZE = 2;
|
|
private static final int CLEAR_CACHE = 3;
|
|
private static final int PACKAGE_MOVE = 4;
|
|
private static final String ATTR_PACKAGE_STATS="PackageStats";
|
|
|
|
// invalid size value used initially and also when size retrieval through PackageManager
|
|
// fails for whatever reason
|
|
private static final int SIZE_INVALID = -1;
|
|
|
|
// Resource strings
|
|
private CharSequence mInvalidSizeStr;
|
|
private CharSequence mComputingStr;
|
|
|
|
// Dialog identifiers used in showDialog
|
|
private static final int DLG_BASE = 0;
|
|
private static final int DLG_CLEAR_DATA = DLG_BASE + 1;
|
|
private static final int DLG_FACTORY_RESET = DLG_BASE + 2;
|
|
private static final int DLG_APP_NOT_FOUND = DLG_BASE + 3;
|
|
private static final int DLG_CANNOT_CLEAR_DATA = DLG_BASE + 4;
|
|
private static final int DLG_FORCE_STOP = DLG_BASE + 5;
|
|
|
|
private Handler mHandler = new Handler() {
|
|
public void handleMessage(Message msg) {
|
|
switch (msg.what) {
|
|
case CLEAR_USER_DATA:
|
|
processClearMsg(msg);
|
|
break;
|
|
case GET_PKG_SIZE:
|
|
refreshSizeInfo(msg);
|
|
break;
|
|
case CLEAR_CACHE:
|
|
// Refresh size info
|
|
mPm.getPackageSizeInfo(mAppInfo.packageName, mSizeObserver);
|
|
break;
|
|
case PACKAGE_MOVE:
|
|
processMoveMsg(msg);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
};
|
|
|
|
class ClearUserDataObserver extends IPackageDataObserver.Stub {
|
|
public void onRemoveCompleted(final String packageName, final boolean succeeded) {
|
|
final Message msg = mHandler.obtainMessage(CLEAR_USER_DATA);
|
|
msg.arg1 = succeeded?OP_SUCCESSFUL:OP_FAILED;
|
|
mHandler.sendMessage(msg);
|
|
}
|
|
}
|
|
|
|
class PkgSizeObserver extends IPackageStatsObserver.Stub {
|
|
public void onGetStatsCompleted(PackageStats pStats, boolean succeeded) {
|
|
Message msg = mHandler.obtainMessage(GET_PKG_SIZE);
|
|
Bundle data = new Bundle();
|
|
data.putParcelable(ATTR_PACKAGE_STATS, pStats);
|
|
msg.setData(data);
|
|
mHandler.sendMessage(msg);
|
|
|
|
}
|
|
}
|
|
|
|
class ClearCacheObserver extends IPackageDataObserver.Stub {
|
|
public void onRemoveCompleted(final String packageName, final boolean succeeded) {
|
|
final Message msg = mHandler.obtainMessage(CLEAR_CACHE);
|
|
msg.arg1 = succeeded ? OP_SUCCESSFUL:OP_FAILED;
|
|
mHandler.sendMessage(msg);
|
|
}
|
|
}
|
|
|
|
class PackageMoveObserver extends IPackageMoveObserver.Stub {
|
|
public void packageMoved(String packageName, int returnCode) throws RemoteException {
|
|
final Message msg = mHandler.obtainMessage(PACKAGE_MOVE);
|
|
msg.arg1 = returnCode;
|
|
mHandler.sendMessage(msg);
|
|
}
|
|
}
|
|
|
|
private String getSizeStr(long size) {
|
|
if (size == SIZE_INVALID) {
|
|
return mInvalidSizeStr.toString();
|
|
}
|
|
return Formatter.formatFileSize(this, size);
|
|
}
|
|
|
|
private void initDataButtons() {
|
|
if (mAppInfo.manageSpaceActivityName != null) {
|
|
mClearDataButton.setText(R.string.manage_space_text);
|
|
} else {
|
|
mClearDataButton.setText(R.string.clear_user_data_text);
|
|
}
|
|
mClearDataButton.setOnClickListener(this);
|
|
initMoveButton();
|
|
}
|
|
|
|
private void initMoveButton() {
|
|
String pkgName = mAppInfo.packageName;
|
|
boolean dataOnly = false;
|
|
ApplicationInfo info1 = null;
|
|
PackageInfo pkgInfo = null;
|
|
|
|
try {
|
|
info1 = mPm.getApplicationInfo(pkgName, 0);
|
|
pkgInfo = mPm.getPackageInfo(mAppInfo.packageName,
|
|
PackageManager.GET_UNINSTALLED_PACKAGES);
|
|
} catch (NameNotFoundException e) {
|
|
}
|
|
dataOnly = (info1 == null) && (mAppInfo != null);
|
|
boolean moveDisable = true;
|
|
if (dataOnly) {
|
|
mMoveAppButton.setText(R.string.move_app);
|
|
} else if ((mAppInfo.flags & ApplicationInfo.FLAG_ON_SDCARD) != 0) {
|
|
mMoveAppButton.setText(R.string.move_app_to_internal);
|
|
moveDisable = false;
|
|
} else {
|
|
moveDisable = (mAppInfo.flags & ApplicationInfo.FLAG_FORWARD_LOCK) != 0 ||
|
|
(mAppInfo.flags & ApplicationInfo.FLAG_SYSTEM) != 0;
|
|
mMoveAppButton.setText(R.string.move_app_to_sdcard);
|
|
}
|
|
if (pkgInfo != null && pkgInfo.installLocation ==
|
|
PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY) {
|
|
// If an application explicitly specifies install location
|
|
// consider that
|
|
moveDisable = true;
|
|
}
|
|
if (moveDisable) {
|
|
mMoveAppButton.setEnabled(false);
|
|
} else {
|
|
mMoveAppButton.setOnClickListener(this);
|
|
mMoveAppButton.setEnabled(true);
|
|
}
|
|
}
|
|
|
|
private void initControlButtons() {
|
|
mUpdatedSysApp = (mAppInfo.flags & ApplicationInfo.FLAG_UPDATED_SYSTEM_APP) != 0;
|
|
boolean enabled = true;
|
|
if (mUpdatedSysApp) {
|
|
mUninstallButton.setText(R.string.app_factory_reset);
|
|
} else if ((mAppInfo.flags & ApplicationInfo.FLAG_SYSTEM) == 0){
|
|
mUninstallButton.setText(R.string.uninstall_text);
|
|
} else {
|
|
// Disable uninstall for system apps
|
|
enabled = false;
|
|
}
|
|
mUninstallButton.setEnabled(enabled);
|
|
if (enabled) {
|
|
// Register listener
|
|
mUninstallButton.setOnClickListener(this);
|
|
}
|
|
}
|
|
|
|
/** Called when the activity is first created. */
|
|
@Override
|
|
protected void onCreate(Bundle icicle) {
|
|
super.onCreate(icicle);
|
|
// Get package manager
|
|
mPm = getPackageManager();
|
|
// Get application's name from intent
|
|
Intent intent = getIntent();
|
|
final String packageName = intent.getStringExtra(ManageApplications.APP_PKG_NAME);
|
|
mComputingStr = getText(R.string.computing_size);
|
|
// Try retrieving package stats again
|
|
CharSequence totalSizeStr, appSizeStr, dataSizeStr;
|
|
totalSizeStr = appSizeStr = dataSizeStr = mComputingStr;
|
|
if(localLOGV) Log.i(TAG, "Have to compute package sizes");
|
|
mSizeObserver = new PkgSizeObserver();
|
|
try {
|
|
mAppInfo = mPm.getApplicationInfo(packageName,
|
|
PackageManager.GET_UNINSTALLED_PACKAGES);
|
|
} catch (NameNotFoundException e) {
|
|
Log.e(TAG, "Exception when retrieving package:"+packageName, e);
|
|
showDialogInner(DLG_APP_NOT_FOUND);
|
|
return;
|
|
}
|
|
setContentView(R.layout.installed_app_details);
|
|
//TODO download str and download url
|
|
// Set default values on sizes
|
|
mTotalSize = (TextView)findViewById(R.id.total_size_text);
|
|
mTotalSize.setText(totalSizeStr);
|
|
mAppSize = (TextView)findViewById(R.id.application_size_text);
|
|
mAppSize.setText(appSizeStr);
|
|
mDataSize = (TextView)findViewById(R.id.data_size_text);
|
|
mDataSize.setText(dataSizeStr);
|
|
// Get Control button panel
|
|
View btnPanel = findViewById(R.id.control_buttons_panel);
|
|
mForceStopButton = (Button) btnPanel.findViewById(R.id.left_button);
|
|
mForceStopButton.setText(R.string.force_stop);
|
|
mUninstallButton = (Button)btnPanel.findViewById(R.id.right_button);
|
|
mForceStopButton.setEnabled(false);
|
|
initControlButtons();
|
|
// Initialize clear data and move install location buttons
|
|
View data_buttons_panel = findViewById(R.id.data_buttons_panel);
|
|
mClearDataButton = (Button) data_buttons_panel.findViewById(R.id.left_button);
|
|
mMoveAppButton = (Button) data_buttons_panel.findViewById(R.id.right_button);
|
|
// Cache section
|
|
mCacheSize = (TextView) findViewById(R.id.cache_size_text);
|
|
mCacheSize.setText(mComputingStr);
|
|
mClearCacheButton = (Button) findViewById(R.id.clear_cache_button);
|
|
|
|
// Get list of preferred activities
|
|
mActivitiesButton = (Button)findViewById(R.id.clear_activities_button);
|
|
List<ComponentName> prefActList = new ArrayList<ComponentName>();
|
|
// Intent list cannot be null. so pass empty list
|
|
List<IntentFilter> intentList = new ArrayList<IntentFilter>();
|
|
mPm.getPreferredActivities(intentList, prefActList, packageName);
|
|
if(localLOGV) Log.i(TAG, "Have "+prefActList.size()+" number of activities in prefered list");
|
|
TextView autoLaunchView = (TextView)findViewById(R.id.auto_launch);
|
|
if(prefActList.size() <= 0) {
|
|
// Disable clear activities button
|
|
autoLaunchView.setText(R.string.auto_launch_disable_text);
|
|
mActivitiesButton.setEnabled(false);
|
|
} else {
|
|
autoLaunchView.setText(R.string.auto_launch_enable_text);
|
|
mActivitiesButton.setOnClickListener(this);
|
|
}
|
|
|
|
// Security permissions section
|
|
LinearLayout permsView = (LinearLayout) findViewById(R.id.permissions_section);
|
|
AppSecurityPermissions asp = new AppSecurityPermissions(this, packageName);
|
|
if(asp.getPermissionCount() > 0) {
|
|
permsView.setVisibility(View.VISIBLE);
|
|
// Make the security sections header visible
|
|
LinearLayout securityList = (LinearLayout) permsView.findViewById(
|
|
R.id.security_settings_list);
|
|
securityList.addView(asp.getPermissionsView());
|
|
} else {
|
|
permsView.setVisibility(View.GONE);
|
|
}
|
|
}
|
|
|
|
private void refreshAppAttributes(PackageInfo pkgInfo) {
|
|
setAppLabelAndIcon(pkgInfo);
|
|
initControlButtons();
|
|
initDataButtons();
|
|
// Refresh size info
|
|
if (mAppInfo != null && mAppInfo.packageName != null) {
|
|
mPm.getPackageSizeInfo(mAppInfo.packageName, mSizeObserver);
|
|
}
|
|
}
|
|
|
|
// Utility method to set applicaiton label and icon.
|
|
private void setAppLabelAndIcon(PackageInfo pkgInfo) {
|
|
View appSnippet = findViewById(R.id.app_snippet);
|
|
ImageView icon = (ImageView) appSnippet.findViewById(R.id.app_icon);
|
|
icon.setImageDrawable(mAppInfo.loadIcon(mPm));
|
|
// Set application name.
|
|
TextView label = (TextView) appSnippet.findViewById(R.id.app_name);
|
|
label.setText(mAppInfo.loadLabel(mPm));
|
|
// Version number of application
|
|
mAppVersion = (TextView) appSnippet.findViewById(R.id.app_size);
|
|
|
|
if (pkgInfo != null && pkgInfo.versionName != null) {
|
|
mAppVersion.setVisibility(View.VISIBLE);
|
|
mAppVersion.setText(getString(R.string.version_text,
|
|
String.valueOf(pkgInfo.versionName)));
|
|
} else {
|
|
mAppVersion.setVisibility(View.INVISIBLE);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onResume() {
|
|
super.onResume();
|
|
PackageInfo pkgInfo;
|
|
// Get application info again to refresh changed properties of application
|
|
try {
|
|
mAppInfo = mPm.getApplicationInfo(mAppInfo.packageName,
|
|
PackageManager.GET_UNINSTALLED_PACKAGES);
|
|
pkgInfo = mPm.getPackageInfo(mAppInfo.packageName,
|
|
PackageManager.GET_UNINSTALLED_PACKAGES);
|
|
} catch (NameNotFoundException e) {
|
|
Log.e(TAG, "Exception when retrieving package:" + mAppInfo.packageName, e);
|
|
showDialogInner(DLG_APP_NOT_FOUND);
|
|
return;
|
|
}
|
|
checkForceStop();
|
|
refreshAppAttributes(pkgInfo);
|
|
}
|
|
|
|
private void setIntentAndFinish(boolean finish, boolean appChanged) {
|
|
if(localLOGV) Log.i(TAG, "appChanged="+appChanged);
|
|
Intent intent = new Intent();
|
|
intent.putExtra(ManageApplications.APP_CHG, appChanged);
|
|
setResult(ManageApplications.RESULT_OK, intent);
|
|
if(finish) {
|
|
finish();
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Private method to handle get size info notification from observer when
|
|
* the async operation from PackageManager is complete. The current user data
|
|
* info has to be refreshed in the manage applications screen as well as the current screen.
|
|
*/
|
|
private void refreshSizeInfo(Message msg) {
|
|
boolean changed = false;
|
|
PackageStats newPs = msg.getData().getParcelable(ATTR_PACKAGE_STATS);
|
|
long newTot = newPs.cacheSize+newPs.codeSize+newPs.dataSize;
|
|
if(mSizeInfo == null) {
|
|
mSizeInfo = newPs;
|
|
String str = getSizeStr(newTot);
|
|
mTotalSize.setText(str);
|
|
mAppSize.setText(getSizeStr(newPs.codeSize));
|
|
mDataSize.setText(getSizeStr(newPs.dataSize));
|
|
mCacheSize.setText(getSizeStr(newPs.cacheSize));
|
|
} else {
|
|
long oldTot = mSizeInfo.cacheSize+mSizeInfo.codeSize+mSizeInfo.dataSize;
|
|
if(newTot != oldTot) {
|
|
String str = getSizeStr(newTot);
|
|
mTotalSize.setText(str);
|
|
changed = true;
|
|
}
|
|
if(newPs.codeSize != mSizeInfo.codeSize) {
|
|
mAppSize.setText(getSizeStr(newPs.codeSize));
|
|
changed = true;
|
|
}
|
|
if(newPs.dataSize != mSizeInfo.dataSize) {
|
|
mDataSize.setText(getSizeStr(newPs.dataSize));
|
|
changed = true;
|
|
}
|
|
if(newPs.cacheSize != mSizeInfo.cacheSize) {
|
|
mCacheSize.setText(getSizeStr(newPs.cacheSize));
|
|
changed = true;
|
|
}
|
|
if(changed) {
|
|
mSizeInfo = newPs;
|
|
}
|
|
}
|
|
// If data size is zero disable clear data button
|
|
if (newPs.dataSize == 0) {
|
|
mClearDataButton.setEnabled(false);
|
|
}
|
|
long data = mSizeInfo.dataSize;
|
|
refreshCacheInfo(newPs.cacheSize);
|
|
}
|
|
|
|
private void refreshCacheInfo(long cacheSize) {
|
|
// Set cache info
|
|
mCacheSize.setText(getSizeStr(cacheSize));
|
|
if (cacheSize <= 0) {
|
|
mClearCacheButton.setEnabled(false);
|
|
} else {
|
|
mClearCacheButton.setOnClickListener(this);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Private method to handle clear message notification from observer when
|
|
* the async operation from PackageManager is complete
|
|
*/
|
|
private void processClearMsg(Message msg) {
|
|
int result = msg.arg1;
|
|
String packageName = mAppInfo.packageName;
|
|
mClearDataButton.setText(R.string.clear_user_data_text);
|
|
if(result == OP_SUCCESSFUL) {
|
|
Log.i(TAG, "Cleared user data for package : "+packageName);
|
|
mPm.getPackageSizeInfo(packageName, mSizeObserver);
|
|
} else {
|
|
mClearDataButton.setEnabled(true);
|
|
}
|
|
}
|
|
|
|
private void processMoveMsg(Message msg) {
|
|
int result = msg.arg1;
|
|
String packageName = mAppInfo.packageName;
|
|
if(result == PackageManager.MOVE_SUCCEEDED) {
|
|
Log.i(TAG, "Moved resources for " + packageName);
|
|
try {
|
|
// Reset flags
|
|
mAppInfo = mPm.getApplicationInfo(packageName,
|
|
PackageManager.GET_UNINSTALLED_PACKAGES);
|
|
initMoveButton();
|
|
} catch (NameNotFoundException e) {
|
|
// TODO error handling
|
|
}
|
|
} else {
|
|
// TODO Present a dialog indicating failure.
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Private method to initiate clearing user data when the user clicks the clear data
|
|
* button for a system package
|
|
*/
|
|
private void initiateClearUserData() {
|
|
mClearDataButton.setEnabled(false);
|
|
// Invoke uninstall or clear user data based on sysPackage
|
|
String packageName = mAppInfo.packageName;
|
|
Log.i(TAG, "Clearing user data for package : " + packageName);
|
|
if(mClearDataObserver == null) {
|
|
mClearDataObserver = new ClearUserDataObserver();
|
|
}
|
|
ActivityManager am = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
|
|
boolean res = am.clearApplicationUserData(packageName, mClearDataObserver);
|
|
if(!res) {
|
|
// Clearing data failed for some obscure reason. Just log error for now
|
|
Log.i(TAG, "Couldnt clear application user data for package:"+packageName);
|
|
showDialogInner(DLG_CANNOT_CLEAR_DATA);
|
|
} else {
|
|
mClearDataButton.setText(R.string.recompute_size);
|
|
}
|
|
}
|
|
|
|
private void showDialogInner(int id) {
|
|
//removeDialog(id);
|
|
showDialog(id);
|
|
}
|
|
|
|
@Override
|
|
public Dialog onCreateDialog(int id, Bundle args) {
|
|
switch (id) {
|
|
case DLG_CLEAR_DATA:
|
|
return new AlertDialog.Builder(this)
|
|
.setTitle(getString(R.string.clear_data_dlg_title))
|
|
.setIcon(android.R.drawable.ic_dialog_alert)
|
|
.setMessage(getString(R.string.clear_data_dlg_text))
|
|
.setPositiveButton(R.string.dlg_ok,
|
|
new DialogInterface.OnClickListener() {
|
|
public void onClick(DialogInterface dialog, int which) {
|
|
// Clear user data here
|
|
initiateClearUserData();
|
|
}
|
|
})
|
|
.setNegativeButton(R.string.dlg_cancel, null)
|
|
.create();
|
|
case DLG_FACTORY_RESET:
|
|
return new AlertDialog.Builder(this)
|
|
.setTitle(getString(R.string.app_factory_reset_dlg_title))
|
|
.setIcon(android.R.drawable.ic_dialog_alert)
|
|
.setMessage(getString(R.string.app_factory_reset_dlg_text))
|
|
.setPositiveButton(R.string.dlg_ok,
|
|
new DialogInterface.OnClickListener() {
|
|
public void onClick(DialogInterface dialog, int which) {
|
|
// Clear user data here
|
|
uninstallPkg(mAppInfo.packageName);
|
|
}
|
|
})
|
|
.setNegativeButton(R.string.dlg_cancel, null)
|
|
.create();
|
|
case DLG_APP_NOT_FOUND:
|
|
return new AlertDialog.Builder(this)
|
|
.setTitle(getString(R.string.app_not_found_dlg_title))
|
|
.setIcon(android.R.drawable.ic_dialog_alert)
|
|
.setMessage(getString(R.string.app_not_found_dlg_title))
|
|
.setNeutralButton(getString(R.string.dlg_ok),
|
|
new DialogInterface.OnClickListener() {
|
|
public void onClick(DialogInterface dialog, int which) {
|
|
//force to recompute changed value
|
|
setIntentAndFinish(true, true);
|
|
}
|
|
})
|
|
.create();
|
|
case DLG_CANNOT_CLEAR_DATA:
|
|
return new AlertDialog.Builder(this)
|
|
.setTitle(getString(R.string.clear_failed_dlg_title))
|
|
.setIcon(android.R.drawable.ic_dialog_alert)
|
|
.setMessage(getString(R.string.clear_failed_dlg_text))
|
|
.setNeutralButton(R.string.dlg_ok,
|
|
new DialogInterface.OnClickListener() {
|
|
public void onClick(DialogInterface dialog, int which) {
|
|
mClearDataButton.setEnabled(false);
|
|
//force to recompute changed value
|
|
setIntentAndFinish(false, false);
|
|
}
|
|
})
|
|
.create();
|
|
case DLG_FORCE_STOP:
|
|
return new AlertDialog.Builder(this)
|
|
.setTitle(getString(R.string.force_stop_dlg_title))
|
|
.setIcon(android.R.drawable.ic_dialog_alert)
|
|
.setMessage(getString(R.string.force_stop_dlg_text))
|
|
.setPositiveButton(R.string.dlg_ok,
|
|
new DialogInterface.OnClickListener() {
|
|
public void onClick(DialogInterface dialog, int which) {
|
|
// Force stop
|
|
forceStopPackage(mAppInfo.packageName);
|
|
}
|
|
})
|
|
.setNegativeButton(R.string.dlg_cancel, null)
|
|
.create();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private void uninstallPkg(String packageName) {
|
|
// Create new intent to launch Uninstaller activity
|
|
Uri packageURI = Uri.parse("package:"+packageName);
|
|
Intent uninstallIntent = new Intent(Intent.ACTION_DELETE, packageURI);
|
|
startActivity(uninstallIntent);
|
|
setIntentAndFinish(true, true);
|
|
}
|
|
|
|
private void forceStopPackage(String pkgName) {
|
|
ActivityManager am = (ActivityManager)getSystemService(
|
|
Context.ACTIVITY_SERVICE);
|
|
am.forceStopPackage(pkgName);
|
|
checkForceStop();
|
|
}
|
|
|
|
private final BroadcastReceiver mCheckKillProcessesReceiver = new BroadcastReceiver() {
|
|
@Override
|
|
public void onReceive(Context context, Intent intent) {
|
|
mForceStopButton.setEnabled(getResultCode() != RESULT_CANCELED);
|
|
mForceStopButton.setOnClickListener(InstalledAppDetails.this);
|
|
}
|
|
};
|
|
|
|
private void checkForceStop() {
|
|
Intent intent = new Intent(Intent.ACTION_QUERY_PACKAGE_RESTART,
|
|
Uri.fromParts("package", mAppInfo.packageName, null));
|
|
intent.putExtra(Intent.EXTRA_PACKAGES, new String[] { mAppInfo.packageName });
|
|
intent.putExtra(Intent.EXTRA_UID, mAppInfo.uid);
|
|
sendOrderedBroadcast(intent, null, mCheckKillProcessesReceiver, null,
|
|
Activity.RESULT_CANCELED, null, null);
|
|
}
|
|
|
|
/*
|
|
* Method implementing functionality of buttons clicked
|
|
* @see android.view.View.OnClickListener#onClick(android.view.View)
|
|
*/
|
|
public void onClick(View v) {
|
|
String packageName = mAppInfo.packageName;
|
|
if(v == mUninstallButton) {
|
|
if (mUpdatedSysApp) {
|
|
showDialogInner(DLG_FACTORY_RESET);
|
|
} else {
|
|
uninstallPkg(packageName);
|
|
}
|
|
} else if(v == mActivitiesButton) {
|
|
mPm.clearPackagePreferredActivities(packageName);
|
|
mActivitiesButton.setEnabled(false);
|
|
} else if(v == mClearDataButton) {
|
|
if (mAppInfo.manageSpaceActivityName != null) {
|
|
Intent intent = new Intent(Intent.ACTION_DEFAULT);
|
|
intent.setClassName(mAppInfo.packageName, mAppInfo.manageSpaceActivityName);
|
|
startActivityForResult(intent, -1);
|
|
} else {
|
|
showDialogInner(DLG_CLEAR_DATA);
|
|
}
|
|
} else if (v == mClearCacheButton) {
|
|
// Lazy initialization of observer
|
|
if (mClearCacheObserver == null) {
|
|
mClearCacheObserver = new ClearCacheObserver();
|
|
}
|
|
mPm.deleteApplicationCacheFiles(packageName, mClearCacheObserver);
|
|
} else if (v == mForceStopButton) {
|
|
forceStopPackage(mAppInfo.packageName);
|
|
} else if (v == mMoveAppButton) {
|
|
if (mPackageMoveObserver == null) {
|
|
mPackageMoveObserver = new PackageMoveObserver();
|
|
}
|
|
int moveFlags = (mAppInfo.flags & ApplicationInfo.FLAG_ON_SDCARD) != 0 ?
|
|
PackageManager.MOVE_INTERNAL : PackageManager.MOVE_EXTERNAL_MEDIA;
|
|
mMoveAppButton.setText(R.string.moving);
|
|
mMoveAppButton.setEnabled(false);
|
|
mPm.movePackage(mAppInfo.packageName, mPackageMoveObserver, moveFlags);
|
|
}
|
|
}
|
|
}
|
|
|