853 lines
33 KiB
Java
Executable File
853 lines
33 KiB
Java
Executable File
/*
|
|
* Copyright (C) 2017 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.applications.appinfo;
|
|
|
|
import static com.android.settingslib.RestrictedLockUtils.EnforcedAdmin;
|
|
|
|
import android.app.Activity;
|
|
import android.app.ActivityManager;
|
|
import android.app.AlertDialog;
|
|
import android.app.Dialog;
|
|
import android.app.DialogFragment;
|
|
import android.app.admin.DevicePolicyManager;
|
|
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.PackageInfo;
|
|
import android.content.pm.PackageManager;
|
|
import android.content.pm.PackageManager.NameNotFoundException;
|
|
import android.content.pm.UserInfo;
|
|
import android.net.Uri;
|
|
import android.os.AsyncTask;
|
|
import android.os.Bundle;
|
|
import android.os.UserHandle;
|
|
import android.os.UserManager;
|
|
import android.text.TextUtils;
|
|
import android.util.Log;
|
|
import android.view.Menu;
|
|
import android.view.MenuInflater;
|
|
import android.view.MenuItem;
|
|
|
|
import androidx.annotation.VisibleForTesting;
|
|
|
|
import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
|
|
import com.android.settings.DeviceAdminAdd;
|
|
import com.android.settings.R;
|
|
import com.android.settings.SettingsActivity;
|
|
import com.android.settings.SettingsPreferenceFragment;
|
|
import com.android.settings.applications.manageapplications.ManageApplications;
|
|
import com.android.settings.core.SubSettingLauncher;
|
|
import com.android.settings.core.instrumentation.InstrumentedDialogFragment;
|
|
import com.android.settings.dashboard.DashboardFragment;
|
|
import com.android.settingslib.RestrictedLockUtils;
|
|
import com.android.settingslib.applications.AppUtils;
|
|
import com.android.settingslib.applications.ApplicationsState;
|
|
import com.android.settingslib.applications.ApplicationsState.AppEntry;
|
|
import com.android.settingslib.core.AbstractPreferenceController;
|
|
import com.android.settingslib.core.lifecycle.Lifecycle;
|
|
|
|
import java.lang.ref.WeakReference;
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.List;
|
|
|
|
|
|
/**
|
|
* Dashboard fragment 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 AppInfoDashboardFragment extends DashboardFragment
|
|
implements ApplicationsState.Callbacks {
|
|
|
|
private static final String TAG = "AppInfoDashboard";
|
|
|
|
// Menu identifiers
|
|
@VisibleForTesting
|
|
static final int UNINSTALL_ALL_USERS_MENU = 1;
|
|
@VisibleForTesting
|
|
static final int UNINSTALL_UPDATES = 2;
|
|
static final int INSTALL_INSTANT_APP_MENU = 3;
|
|
|
|
// Result code identifiers
|
|
@VisibleForTesting
|
|
static final int REQUEST_UNINSTALL = 0;
|
|
private static final int REQUEST_REMOVE_DEVICE_ADMIN = 1;
|
|
|
|
static final int SUB_INFO_FRAGMENT = 1;
|
|
|
|
static final int LOADER_CHART_DATA = 2;
|
|
static final int LOADER_STORAGE = 3;
|
|
static final int LOADER_BATTERY = 4;
|
|
|
|
// Dialog identifiers used in showDialog
|
|
private static final int DLG_BASE = 0;
|
|
private static final int DLG_FORCE_STOP = DLG_BASE + 1;
|
|
private static final int DLG_DISABLE = DLG_BASE + 2;
|
|
private static final int DLG_SPECIAL_DISABLE = DLG_BASE + 3;
|
|
static final int DLG_CLEAR_INSTANT_APP = DLG_BASE + 4;
|
|
|
|
public static final String ARG_PACKAGE_NAME = "package";
|
|
public static final String ARG_PACKAGE_UID = "uid";
|
|
|
|
private static final boolean localLOGV = false;
|
|
|
|
private EnforcedAdmin mAppsControlDisallowedAdmin;
|
|
private boolean mAppsControlDisallowedBySystem;
|
|
|
|
private ApplicationsState mState;
|
|
private ApplicationsState.Session mSession;
|
|
private ApplicationsState.AppEntry mAppEntry;
|
|
private PackageInfo mPackageInfo;
|
|
private int mUserId;
|
|
private String mPackageName;
|
|
|
|
private DevicePolicyManager mDpm;
|
|
private UserManager mUserManager;
|
|
private PackageManager mPm;
|
|
|
|
private boolean mFinishing;
|
|
private boolean mListeningToPackageRemove;
|
|
|
|
|
|
private boolean mInitialized;
|
|
private boolean mShowUninstalled;
|
|
private boolean mUpdatedSysApp = false;
|
|
private boolean mDisableAfterUninstall;
|
|
|
|
private List<Callback> mCallbacks = new ArrayList<>();
|
|
|
|
private InstantAppButtonsPreferenceController mInstantAppButtonPreferenceController;
|
|
private AppActionButtonPreferenceController mAppActionButtonPreferenceController;
|
|
|
|
/**
|
|
* Callback to invoke when app info has been changed.
|
|
*/
|
|
public interface Callback {
|
|
void refreshUi();
|
|
}
|
|
|
|
private boolean isDisabledUntilUsed() {
|
|
return mAppEntry.info.enabledSetting
|
|
== PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED;
|
|
}
|
|
|
|
@Override
|
|
public void onAttach(Context context) {
|
|
super.onAttach(context);
|
|
final String packageName = getPackageName();
|
|
use(TimeSpentInAppPreferenceController.class).setPackageName(packageName);
|
|
|
|
use(AppDataUsagePreferenceController.class).setParentFragment(this);
|
|
final AppInstallerInfoPreferenceController installer =
|
|
use(AppInstallerInfoPreferenceController.class);
|
|
installer.setPackageName(packageName);
|
|
installer.setParentFragment(this);
|
|
use(AppInstallerPreferenceCategoryController.class).setChildren(Arrays.asList(installer));
|
|
use(AppNotificationPreferenceController.class).setParentFragment(this);
|
|
use(AppOpenByDefaultPreferenceController.class).setParentFragment(this);
|
|
use(AppPermissionPreferenceController.class).setParentFragment(this);
|
|
use(AppPermissionPreferenceController.class).setPackageName(packageName);
|
|
use(AppSettingPreferenceController.class)
|
|
.setPackageName(packageName)
|
|
.setParentFragment(this);
|
|
use(AppStoragePreferenceController.class).setParentFragment(this);
|
|
use(AppVersionPreferenceController.class).setParentFragment(this);
|
|
use(InstantAppDomainsPreferenceController.class).setParentFragment(this);
|
|
|
|
final WriteSystemSettingsPreferenceController writeSystemSettings =
|
|
use(WriteSystemSettingsPreferenceController.class);
|
|
writeSystemSettings.setParentFragment(this);
|
|
|
|
final DrawOverlayDetailPreferenceController drawOverlay =
|
|
use(DrawOverlayDetailPreferenceController.class);
|
|
drawOverlay.setParentFragment(this);
|
|
|
|
final PictureInPictureDetailPreferenceController pip =
|
|
use(PictureInPictureDetailPreferenceController.class);
|
|
pip.setPackageName(packageName);
|
|
pip.setParentFragment(this);
|
|
final ExternalSourceDetailPreferenceController externalSource =
|
|
use(ExternalSourceDetailPreferenceController.class);
|
|
externalSource.setPackageName(packageName);
|
|
externalSource.setParentFragment(this);
|
|
|
|
use(AdvancedAppInfoPreferenceCategoryController.class).setChildren(Arrays.asList(
|
|
writeSystemSettings, drawOverlay, pip, externalSource));
|
|
}
|
|
|
|
@Override
|
|
public void onCreate(Bundle icicle) {
|
|
super.onCreate(icicle);
|
|
mFinishing = false;
|
|
final Activity activity = getActivity();
|
|
mDpm = (DevicePolicyManager) activity.getSystemService(Context.DEVICE_POLICY_SERVICE);
|
|
mUserManager = (UserManager) activity.getSystemService(Context.USER_SERVICE);
|
|
mPm = activity.getPackageManager();
|
|
if (!ensurePackageInfoAvailable(activity)) {
|
|
return;
|
|
}
|
|
startListeningToPackageRemove();
|
|
|
|
setHasOptionsMenu(true);
|
|
}
|
|
|
|
@Override
|
|
public void onCreatePreferences(Bundle savedInstanceState, String rootKey) {
|
|
if (!ensurePackageInfoAvailable(getActivity())) {
|
|
return;
|
|
}
|
|
super.onCreatePreferences(savedInstanceState, rootKey);
|
|
}
|
|
|
|
@Override
|
|
public void onDestroy() {
|
|
stopListeningToPackageRemove();
|
|
super.onDestroy();
|
|
}
|
|
|
|
@Override
|
|
public int getMetricsCategory() {
|
|
return MetricsEvent.APPLICATIONS_INSTALLED_APP_DETAILS;
|
|
}
|
|
|
|
@Override
|
|
public void onResume() {
|
|
super.onResume();
|
|
final Activity activity = getActivity();
|
|
mAppsControlDisallowedAdmin = RestrictedLockUtils.checkIfRestrictionEnforced(activity,
|
|
UserManager.DISALLOW_APPS_CONTROL, mUserId);
|
|
mAppsControlDisallowedBySystem = RestrictedLockUtils.hasBaseUserRestriction(activity,
|
|
UserManager.DISALLOW_APPS_CONTROL, mUserId);
|
|
|
|
if (!refreshUi()) {
|
|
setIntentAndFinish(true, true);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
protected int getPreferenceScreenResId() {
|
|
return R.xml.app_info_settings;
|
|
}
|
|
|
|
@Override
|
|
protected String getLogTag() {
|
|
return TAG;
|
|
}
|
|
|
|
@Override
|
|
protected List<AbstractPreferenceController> createPreferenceControllers(Context context) {
|
|
retrieveAppEntry();
|
|
if (mPackageInfo == null) {
|
|
return null;
|
|
}
|
|
final String packageName = getPackageName();
|
|
final List<AbstractPreferenceController> controllers = new ArrayList<>();
|
|
final Lifecycle lifecycle = getLifecycle();
|
|
|
|
// The following are controllers for preferences that needs to refresh the preference state
|
|
// when app state changes.
|
|
controllers.add(
|
|
new AppHeaderViewPreferenceController(context, this, packageName, lifecycle));
|
|
mAppActionButtonPreferenceController =
|
|
new AppActionButtonPreferenceController(context, this, packageName);
|
|
controllers.add(mAppActionButtonPreferenceController);
|
|
|
|
for (AbstractPreferenceController controller : controllers) {
|
|
mCallbacks.add((Callback) controller);
|
|
}
|
|
|
|
// The following are controllers for preferences that don't need to refresh the preference
|
|
// state when app state changes.
|
|
mInstantAppButtonPreferenceController =
|
|
new InstantAppButtonsPreferenceController(context, this, packageName, lifecycle);
|
|
controllers.add(mInstantAppButtonPreferenceController);
|
|
controllers.add(new AppBatteryPreferenceController(context, this, packageName, lifecycle));
|
|
controllers.add(new AppMemoryPreferenceController(context, this, lifecycle));
|
|
controllers.add(new DefaultHomeShortcutPreferenceController(context, packageName));
|
|
controllers.add(new DefaultBrowserShortcutPreferenceController(context, packageName));
|
|
controllers.add(new DefaultPhoneShortcutPreferenceController(context, packageName));
|
|
controllers.add(new DefaultEmergencyShortcutPreferenceController(context, packageName));
|
|
controllers.add(new DefaultSmsShortcutPreferenceController(context, packageName));
|
|
|
|
return controllers;
|
|
}
|
|
|
|
void addToCallbackList(Callback callback) {
|
|
if (callback != null) {
|
|
mCallbacks.add(callback);
|
|
}
|
|
}
|
|
|
|
ApplicationsState.AppEntry getAppEntry() {
|
|
return mAppEntry;
|
|
}
|
|
|
|
void setAppEntry(ApplicationsState.AppEntry appEntry) {
|
|
mAppEntry = appEntry;
|
|
}
|
|
|
|
PackageInfo getPackageInfo() {
|
|
return mPackageInfo;
|
|
}
|
|
|
|
@Override
|
|
public void onPackageSizeChanged(String packageName) {
|
|
if (!TextUtils.equals(packageName, mPackageName)) {
|
|
Log.d(TAG, "Package change irrelevant, skipping");
|
|
return;
|
|
}
|
|
refreshUi();
|
|
}
|
|
|
|
/**
|
|
* Ensures the {@link PackageInfo} is available to proceed. If it's not available, the fragment
|
|
* will finish.
|
|
*
|
|
* @return true if packageInfo is available.
|
|
*/
|
|
@VisibleForTesting
|
|
boolean ensurePackageInfoAvailable(Activity activity) {
|
|
if (mPackageInfo == null) {
|
|
mFinishing = true;
|
|
Log.w(TAG, "Package info not available. Is this package already uninstalled?");
|
|
activity.finishAndRemoveTask();
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
|
|
super.onCreateOptionsMenu(menu, inflater);
|
|
menu.add(0, UNINSTALL_UPDATES, 0, R.string.app_factory_reset)
|
|
.setShowAsAction(MenuItem.SHOW_AS_ACTION_NEVER);
|
|
menu.add(0, UNINSTALL_ALL_USERS_MENU, 1, R.string.uninstall_all_users_text)
|
|
.setShowAsAction(MenuItem.SHOW_AS_ACTION_NEVER);
|
|
}
|
|
|
|
@Override
|
|
public void onPrepareOptionsMenu(Menu menu) {
|
|
if (mFinishing) {
|
|
return;
|
|
}
|
|
super.onPrepareOptionsMenu(menu);
|
|
menu.findItem(UNINSTALL_ALL_USERS_MENU).setVisible(shouldShowUninstallForAll(mAppEntry));
|
|
mUpdatedSysApp = (mAppEntry.info.flags & ApplicationInfo.FLAG_UPDATED_SYSTEM_APP) != 0;
|
|
final MenuItem uninstallUpdatesItem = menu.findItem(UNINSTALL_UPDATES);
|
|
final boolean uninstallUpdateDisabled = getContext().getResources().getBoolean(
|
|
R.bool.config_disable_uninstall_update);
|
|
uninstallUpdatesItem.setVisible(mUserManager.isAdminUser()
|
|
&& mUpdatedSysApp
|
|
&& !mAppsControlDisallowedBySystem
|
|
&& !uninstallUpdateDisabled);
|
|
if (uninstallUpdatesItem.isVisible()) {
|
|
RestrictedLockUtils.setMenuItemAsDisabledByAdmin(getActivity(),
|
|
uninstallUpdatesItem, mAppsControlDisallowedAdmin);
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean onOptionsItemSelected(MenuItem item) {
|
|
switch (item.getItemId()) {
|
|
case UNINSTALL_ALL_USERS_MENU:
|
|
uninstallPkg(mAppEntry.info.packageName, true, false);
|
|
return true;
|
|
case UNINSTALL_UPDATES:
|
|
uninstallPkg(mAppEntry.info.packageName, false, false);
|
|
return true;
|
|
}
|
|
return super.onOptionsItemSelected(item);
|
|
}
|
|
|
|
@Override
|
|
public void onActivityResult(int requestCode, int resultCode, Intent data) {
|
|
super.onActivityResult(requestCode, resultCode, data);
|
|
switch (requestCode) {
|
|
case REQUEST_UNINSTALL:
|
|
// Refresh option menu
|
|
getActivity().invalidateOptionsMenu();
|
|
|
|
if (mDisableAfterUninstall) {
|
|
mDisableAfterUninstall = false;
|
|
new DisableChanger(this, mAppEntry.info,
|
|
PackageManager.COMPONENT_ENABLED_STATE_DISABLED_USER)
|
|
.execute((Object) null);
|
|
}
|
|
if (!refreshUi()) {
|
|
onPackageRemoved();
|
|
} else {
|
|
startListeningToPackageRemove();
|
|
}
|
|
break;
|
|
case REQUEST_REMOVE_DEVICE_ADMIN:
|
|
if (!refreshUi()) {
|
|
setIntentAndFinish(true, true);
|
|
} else {
|
|
startListeningToPackageRemove();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
@VisibleForTesting
|
|
boolean shouldShowUninstallForAll(AppEntry appEntry) {
|
|
boolean showIt = true;
|
|
if (mUpdatedSysApp) {
|
|
showIt = false;
|
|
} else if (appEntry == null) {
|
|
showIt = false;
|
|
} else if ((appEntry.info.flags & ApplicationInfo.FLAG_SYSTEM) != 0) {
|
|
showIt = false;
|
|
} else if (mPackageInfo == null || mDpm.packageHasActiveAdmins(mPackageInfo.packageName)) {
|
|
showIt = false;
|
|
} else if (UserHandle.myUserId() != 0) {
|
|
showIt = false;
|
|
} else if (mUserManager.getUsers().size() < 2) {
|
|
showIt = false;
|
|
} else if (getNumberOfUserWithPackageInstalled(mPackageName) < 2
|
|
&& (appEntry.info.flags & ApplicationInfo.FLAG_INSTALLED) != 0) {
|
|
showIt = false;
|
|
} else if (AppUtils.isInstant(appEntry.info)) {
|
|
showIt = false;
|
|
}
|
|
return showIt;
|
|
}
|
|
|
|
@VisibleForTesting
|
|
boolean refreshUi() {
|
|
retrieveAppEntry();
|
|
if (mAppEntry == null) {
|
|
return false; // onCreate must have failed, make sure to exit
|
|
}
|
|
|
|
if (mPackageInfo == null) {
|
|
return false; // onCreate must have failed, make sure to exit
|
|
}
|
|
|
|
mState.ensureIcon(mAppEntry);
|
|
|
|
// Update the preference summaries.
|
|
for (Callback callback : mCallbacks) {
|
|
callback.refreshUi();
|
|
}
|
|
|
|
if (!mInitialized) {
|
|
// First time init: are we displaying an uninstalled app?
|
|
mInitialized = true;
|
|
mShowUninstalled = (mAppEntry.info.flags & ApplicationInfo.FLAG_INSTALLED) == 0;
|
|
} else {
|
|
// All other times: if the app no longer exists then we want
|
|
// to go away.
|
|
try {
|
|
final ApplicationInfo ainfo = getActivity().getPackageManager().getApplicationInfo(
|
|
mAppEntry.info.packageName,
|
|
PackageManager.MATCH_DISABLED_COMPONENTS
|
|
| PackageManager.MATCH_ANY_USER);
|
|
if (!mShowUninstalled) {
|
|
// If we did not start out with the app uninstalled, then
|
|
// it transitioning to the uninstalled state for the current
|
|
// user means we should go away as well.
|
|
return (ainfo.flags & ApplicationInfo.FLAG_INSTALLED) != 0;
|
|
}
|
|
} catch (NameNotFoundException e) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
@VisibleForTesting
|
|
AlertDialog createDialog(int id, int errorCode) {
|
|
switch (id) {
|
|
case DLG_DISABLE:
|
|
return new AlertDialog.Builder(getActivity())
|
|
.setMessage(getActivity().getText(R.string.app_disable_dlg_text))
|
|
.setPositiveButton(R.string.app_disable_dlg_positive,
|
|
new DialogInterface.OnClickListener() {
|
|
public void onClick(DialogInterface dialog, int which) {
|
|
// Disable the app
|
|
mMetricsFeatureProvider.action(getContext(),
|
|
MetricsEvent.ACTION_SETTINGS_DISABLE_APP);
|
|
new DisableChanger(AppInfoDashboardFragment.this,
|
|
mAppEntry.info,
|
|
PackageManager
|
|
.COMPONENT_ENABLED_STATE_DISABLED_USER)
|
|
.execute((Object) null);
|
|
}
|
|
})
|
|
.setNegativeButton(R.string.dlg_cancel, null)
|
|
.create();
|
|
case DLG_SPECIAL_DISABLE:
|
|
return new AlertDialog.Builder(getActivity())
|
|
.setMessage(getActivity().getText(R.string.app_disable_dlg_text))
|
|
.setPositiveButton(R.string.app_disable_dlg_positive,
|
|
new DialogInterface.OnClickListener() {
|
|
public void onClick(DialogInterface dialog, int which) {
|
|
// Disable the app and ask for uninstall
|
|
mMetricsFeatureProvider.action(getContext(),
|
|
MetricsEvent.ACTION_SETTINGS_DISABLE_APP);
|
|
uninstallPkg(mAppEntry.info.packageName,
|
|
false, true);
|
|
}
|
|
})
|
|
.setNegativeButton(R.string.dlg_cancel, null)
|
|
.create();
|
|
case DLG_FORCE_STOP:
|
|
return new AlertDialog.Builder(getActivity())
|
|
.setTitle(getActivity().getText(R.string.force_stop_dlg_title))
|
|
.setMessage(getActivity().getText(R.string.force_stop_dlg_text))
|
|
.setPositiveButton(R.string.dlg_ok, new DialogInterface.OnClickListener() {
|
|
public void onClick(DialogInterface dialog, int which) {
|
|
// Force stop
|
|
forceStopPackage(mAppEntry.info.packageName);
|
|
}
|
|
})
|
|
.setNegativeButton(R.string.dlg_cancel, null)
|
|
.create();
|
|
}
|
|
return mInstantAppButtonPreferenceController.createDialog(id);
|
|
}
|
|
|
|
private void uninstallPkg(String packageName, boolean allUsers, boolean andDisable) {
|
|
stopListeningToPackageRemove();
|
|
// Create new intent to launch Uninstaller activity
|
|
final Uri packageURI = Uri.parse("package:" + packageName);
|
|
final Intent uninstallIntent = new Intent(Intent.ACTION_UNINSTALL_PACKAGE, packageURI);
|
|
uninstallIntent.putExtra(Intent.EXTRA_UNINSTALL_ALL_USERS, allUsers);
|
|
mMetricsFeatureProvider.action(
|
|
getContext(), MetricsEvent.ACTION_SETTINGS_UNINSTALL_APP);
|
|
startActivityForResult(uninstallIntent, REQUEST_UNINSTALL);
|
|
mDisableAfterUninstall = andDisable;
|
|
}
|
|
|
|
private void forceStopPackage(String pkgName) {
|
|
mMetricsFeatureProvider.action(getContext(), MetricsEvent.ACTION_APP_FORCE_STOP, pkgName);
|
|
final ActivityManager am = (ActivityManager) getActivity().getSystemService(
|
|
Context.ACTIVITY_SERVICE);
|
|
Log.d(TAG, "Stopping package " + pkgName);
|
|
am.forceStopPackage(pkgName);
|
|
final int userId = UserHandle.getUserId(mAppEntry.info.uid);
|
|
mState.invalidatePackage(pkgName, userId);
|
|
final AppEntry newEnt = mState.getEntry(pkgName, userId);
|
|
if (newEnt != null) {
|
|
mAppEntry = newEnt;
|
|
}
|
|
mAppActionButtonPreferenceController.checkForceStop(mAppEntry, mPackageInfo);
|
|
}
|
|
|
|
public static void startAppInfoFragment(Class<?> fragment, int title, Bundle args,
|
|
SettingsPreferenceFragment caller, AppEntry appEntry) {
|
|
// start new fragment to display extended information
|
|
if (args == null) {
|
|
args = new Bundle();
|
|
}
|
|
args.putString(ARG_PACKAGE_NAME, appEntry.info.packageName);
|
|
args.putInt(ARG_PACKAGE_UID, appEntry.info.uid);
|
|
new SubSettingLauncher(caller.getContext())
|
|
.setDestination(fragment.getName())
|
|
.setArguments(args)
|
|
.setTitle(title)
|
|
.setResultListener(caller, SUB_INFO_FRAGMENT)
|
|
.setSourceMetricsCategory(caller.getMetricsCategory())
|
|
.launch();
|
|
}
|
|
|
|
void handleUninstallButtonClick() {
|
|
if (mAppEntry == null) {
|
|
setIntentAndFinish(true, true);
|
|
return;
|
|
}
|
|
final String packageName = mAppEntry.info.packageName;
|
|
if (mDpm.packageHasActiveAdmins(mPackageInfo.packageName)) {
|
|
stopListeningToPackageRemove();
|
|
final Activity activity = getActivity();
|
|
final Intent uninstallDAIntent = new Intent(activity, DeviceAdminAdd.class);
|
|
uninstallDAIntent.putExtra(DeviceAdminAdd.EXTRA_DEVICE_ADMIN_PACKAGE_NAME,
|
|
mPackageName);
|
|
mMetricsFeatureProvider.action(
|
|
activity, MetricsEvent.ACTION_SETTINGS_UNINSTALL_DEVICE_ADMIN);
|
|
activity.startActivityForResult(uninstallDAIntent, REQUEST_REMOVE_DEVICE_ADMIN);
|
|
return;
|
|
}
|
|
final EnforcedAdmin admin = RestrictedLockUtils.checkIfUninstallBlocked(getActivity(),
|
|
packageName, mUserId);
|
|
final boolean uninstallBlockedBySystem = mAppsControlDisallowedBySystem ||
|
|
RestrictedLockUtils.hasBaseUserRestriction(getActivity(), packageName, mUserId);
|
|
if (admin != null && !uninstallBlockedBySystem) {
|
|
RestrictedLockUtils.sendShowAdminSupportDetailsIntent(getActivity(), admin);
|
|
} else if ((mAppEntry.info.flags & ApplicationInfo.FLAG_SYSTEM) != 0) {
|
|
if (mAppEntry.info.enabled && !isDisabledUntilUsed()) {
|
|
// If the system app has an update and this is the only user on the device,
|
|
// then offer to downgrade the app, otherwise only offer to disable the
|
|
// app for this user.
|
|
if (mUpdatedSysApp && isSingleUser()) {
|
|
showDialogInner(DLG_SPECIAL_DISABLE, 0);
|
|
} else {
|
|
showDialogInner(DLG_DISABLE, 0);
|
|
}
|
|
} else {
|
|
mMetricsFeatureProvider.action(
|
|
getActivity(),
|
|
MetricsEvent.ACTION_SETTINGS_ENABLE_APP);
|
|
new DisableChanger(this, mAppEntry.info,
|
|
PackageManager.COMPONENT_ENABLED_STATE_ENABLED)
|
|
.execute((Object) null);
|
|
}
|
|
} else if ((mAppEntry.info.flags & ApplicationInfo.FLAG_INSTALLED) == 0) {
|
|
uninstallPkg(packageName, true, false);
|
|
} else {
|
|
uninstallPkg(packageName, false, false);
|
|
}
|
|
}
|
|
|
|
void handleForceStopButtonClick() {
|
|
if (mAppEntry == null) {
|
|
setIntentAndFinish(true, true);
|
|
return;
|
|
}
|
|
if (mAppsControlDisallowedAdmin != null && !mAppsControlDisallowedBySystem) {
|
|
RestrictedLockUtils.sendShowAdminSupportDetailsIntent(
|
|
getActivity(), mAppsControlDisallowedAdmin);
|
|
} else {
|
|
showDialogInner(DLG_FORCE_STOP, 0);
|
|
//forceStopPackage(mAppInfo.packageName);
|
|
}
|
|
}
|
|
|
|
/** Returns whether there is only one user on this device, not including the system-only user */
|
|
private boolean isSingleUser() {
|
|
final int userCount = mUserManager.getUserCount();
|
|
return userCount == 1 || (mUserManager.isSplitSystemUser() && userCount == 2);
|
|
}
|
|
|
|
private void onPackageRemoved() {
|
|
getActivity().finishActivity(SUB_INFO_FRAGMENT);
|
|
getActivity().finishAndRemoveTask();
|
|
}
|
|
|
|
@VisibleForTesting
|
|
int getNumberOfUserWithPackageInstalled(String packageName) {
|
|
final List<UserInfo> userInfos = mUserManager.getUsers(true);
|
|
int count = 0;
|
|
|
|
for (final UserInfo userInfo : userInfos) {
|
|
try {
|
|
// Use this API to check whether user has this package
|
|
final ApplicationInfo info = mPm.getApplicationInfoAsUser(
|
|
packageName, PackageManager.GET_META_DATA, userInfo.id);
|
|
if ((info.flags & ApplicationInfo.FLAG_INSTALLED) != 0) {
|
|
count++;
|
|
}
|
|
} catch (NameNotFoundException e) {
|
|
Log.e(TAG, "Package: " + packageName + " not found for user: " + userInfo.id);
|
|
}
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
private static class DisableChanger extends AsyncTask<Object, Object, Object> {
|
|
final PackageManager mPm;
|
|
final WeakReference<AppInfoDashboardFragment> mActivity;
|
|
final ApplicationInfo mInfo;
|
|
final int mState;
|
|
|
|
DisableChanger(AppInfoDashboardFragment activity, ApplicationInfo info, int state) {
|
|
mPm = activity.mPm;
|
|
mActivity = new WeakReference<AppInfoDashboardFragment>(activity);
|
|
mInfo = info;
|
|
mState = state;
|
|
}
|
|
|
|
@Override
|
|
protected Object doInBackground(Object... params) {
|
|
mPm.setApplicationEnabledSetting(mInfo.packageName, mState, 0);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
private String getPackageName() {
|
|
if (mPackageName != null) {
|
|
return mPackageName;
|
|
}
|
|
final Bundle args = getArguments();
|
|
mPackageName = (args != null) ? args.getString(ARG_PACKAGE_NAME) : null;
|
|
if (mPackageName == null) {
|
|
final Intent intent = (args == null) ?
|
|
getActivity().getIntent() : (Intent) args.getParcelable("intent");
|
|
if (intent != null) {
|
|
mPackageName = intent.getData().getSchemeSpecificPart();
|
|
}
|
|
}
|
|
return mPackageName;
|
|
}
|
|
|
|
@VisibleForTesting
|
|
void retrieveAppEntry() {
|
|
final Activity activity = getActivity();
|
|
if (activity == null) {
|
|
return;
|
|
}
|
|
if (mState == null) {
|
|
mState = ApplicationsState.getInstance(activity.getApplication());
|
|
mSession = mState.newSession(this, getLifecycle());
|
|
}
|
|
mUserId = UserHandle.myUserId();
|
|
mAppEntry = mState.getEntry(getPackageName(), UserHandle.myUserId());
|
|
if (mAppEntry != null) {
|
|
// Get application info again to refresh changed properties of application
|
|
try {
|
|
mPackageInfo = activity.getPackageManager().getPackageInfo(
|
|
mAppEntry.info.packageName,
|
|
PackageManager.MATCH_DISABLED_COMPONENTS |
|
|
PackageManager.MATCH_ANY_USER |
|
|
PackageManager.GET_SIGNATURES |
|
|
PackageManager.GET_PERMISSIONS);
|
|
} catch (NameNotFoundException e) {
|
|
Log.e(TAG, "Exception when retrieving package:" + mAppEntry.info.packageName, e);
|
|
}
|
|
} else {
|
|
Log.w(TAG, "Missing AppEntry; maybe reinstalling?");
|
|
mPackageInfo = null;
|
|
}
|
|
}
|
|
|
|
private void setIntentAndFinish(boolean finish, boolean appChanged) {
|
|
if (localLOGV) Log.i(TAG, "appChanged=" + appChanged);
|
|
final Intent intent = new Intent();
|
|
intent.putExtra(ManageApplications.APP_CHG, appChanged);
|
|
final SettingsActivity sa = (SettingsActivity) getActivity();
|
|
sa.finishPreferencePanel(Activity.RESULT_OK, intent);
|
|
mFinishing = true;
|
|
}
|
|
|
|
void showDialogInner(int id, int moveErrorCode) {
|
|
final DialogFragment newFragment = MyAlertDialogFragment.newInstance(id, moveErrorCode);
|
|
newFragment.setTargetFragment(this, 0);
|
|
newFragment.show(getFragmentManager(), "dialog " + id);
|
|
}
|
|
|
|
@Override
|
|
public void onRunningStateChanged(boolean running) {
|
|
// No op.
|
|
}
|
|
|
|
@Override
|
|
public void onRebuildComplete(ArrayList<AppEntry> apps) {
|
|
// No op.
|
|
}
|
|
|
|
@Override
|
|
public void onPackageIconChanged() {
|
|
// No op.
|
|
}
|
|
|
|
@Override
|
|
public void onAllSizesComputed() {
|
|
// No op.
|
|
}
|
|
|
|
@Override
|
|
public void onLauncherInfoChanged() {
|
|
// No op.
|
|
}
|
|
|
|
@Override
|
|
public void onLoadEntriesCompleted() {
|
|
// No op.
|
|
}
|
|
|
|
@Override
|
|
public void onPackageListChanged() {
|
|
if (!refreshUi()) {
|
|
setIntentAndFinish(true, true);
|
|
}
|
|
}
|
|
|
|
public static class MyAlertDialogFragment extends InstrumentedDialogFragment {
|
|
|
|
private static final String ARG_ID = "id";
|
|
|
|
@Override
|
|
public int getMetricsCategory() {
|
|
return MetricsEvent.DIALOG_APP_INFO_ACTION;
|
|
}
|
|
|
|
@Override
|
|
public Dialog onCreateDialog(Bundle savedInstanceState) {
|
|
final int id = getArguments().getInt(ARG_ID);
|
|
final int errorCode = getArguments().getInt("moveError");
|
|
final Dialog dialog =
|
|
((AppInfoDashboardFragment) getTargetFragment()).createDialog(id, errorCode);
|
|
if (dialog == null) {
|
|
throw new IllegalArgumentException("unknown id " + id);
|
|
}
|
|
return dialog;
|
|
}
|
|
|
|
public static MyAlertDialogFragment newInstance(int id, int errorCode) {
|
|
final MyAlertDialogFragment dialogFragment = new MyAlertDialogFragment();
|
|
final Bundle args = new Bundle();
|
|
args.putInt(ARG_ID, id);
|
|
args.putInt("moveError", errorCode);
|
|
dialogFragment.setArguments(args);
|
|
return dialogFragment;
|
|
}
|
|
}
|
|
|
|
@VisibleForTesting
|
|
void startListeningToPackageRemove() {
|
|
if (mListeningToPackageRemove) {
|
|
return;
|
|
}
|
|
mListeningToPackageRemove = true;
|
|
final IntentFilter filter = new IntentFilter(Intent.ACTION_PACKAGE_REMOVED);
|
|
filter.addDataScheme("package");
|
|
getContext().registerReceiver(mPackageRemovedReceiver, filter);
|
|
}
|
|
|
|
private void stopListeningToPackageRemove() {
|
|
if (!mListeningToPackageRemove) {
|
|
return;
|
|
}
|
|
mListeningToPackageRemove = false;
|
|
getContext().unregisterReceiver(mPackageRemovedReceiver);
|
|
}
|
|
|
|
@VisibleForTesting
|
|
final BroadcastReceiver mPackageRemovedReceiver = new BroadcastReceiver() {
|
|
@Override
|
|
public void onReceive(Context context, Intent intent) {
|
|
final String packageName = intent.getData().getSchemeSpecificPart();
|
|
if (!mFinishing && (mAppEntry == null || mAppEntry.info == null
|
|
|| TextUtils.equals(mAppEntry.info.packageName, packageName))) {
|
|
onPackageRemoved();
|
|
}
|
|
}
|
|
};
|
|
|
|
}
|