Merge "Import translations. DO NOT MERGE" into oc-dev
diff --git a/src/com/android/settings/development/DevelopmentSettings.java b/src/com/android/settings/development/DevelopmentSettings.java
index 96e4ce0..2bfb602 100644
--- a/src/com/android/settings/development/DevelopmentSettings.java
+++ b/src/com/android/settings/development/DevelopmentSettings.java
@@ -2055,6 +2055,20 @@
codecTypeValue = BluetoothCodecConfig.SOURCE_CODEC_TYPE_LDAC;
codecPriorityValue = BluetoothCodecConfig.CODEC_PRIORITY_HIGHEST;
break;
+ case 6:
+ synchronized (mBluetoothA2dpLock) {
+ if (mBluetoothA2dp != null) {
+ mBluetoothA2dp.enableOptionalCodecs();
+ }
+ }
+ return;
+ case 7:
+ synchronized (mBluetoothA2dpLock) {
+ if (mBluetoothA2dp != null) {
+ mBluetoothA2dp.disableOptionalCodecs();
+ }
+ }
+ return;
default:
break;
}
diff --git a/src/com/android/settings/display/NightDisplaySettings.java b/src/com/android/settings/display/NightDisplaySettings.java
index bc90eb9..1da16fe 100644
--- a/src/com/android/settings/display/NightDisplaySettings.java
+++ b/src/com/android/settings/display/NightDisplaySettings.java
@@ -70,8 +70,6 @@
mTimeFormatter.setTimeZone(TimeZone.getTimeZone("UTC"));
mTemperaturePreference.setMax(convertTemperature(mController.getMinimumColorTemperature()));
- mTemperaturePreference.setDefaultProgress(convertTemperature(
- mController.getDefaultColorTemperature()));
mTemperaturePreference.setContinuousUpdates(true);
}
diff --git a/src/com/android/settings/enterprise/DevicePolicyManagerWrapper.java b/src/com/android/settings/enterprise/DevicePolicyManagerWrapper.java
index e988fda..a154a2f 100644
--- a/src/com/android/settings/enterprise/DevicePolicyManagerWrapper.java
+++ b/src/com/android/settings/enterprise/DevicePolicyManagerWrapper.java
@@ -129,4 +129,25 @@
* @see android.app.admin.DevicePolicyManager#getOwnerInstalledCaCerts
*/
List<String> getOwnerInstalledCaCerts(@NonNull UserHandle user);
+
+ /**
+ * Calls {@code DevicePolicyManager.isDeviceOwnerAppOnAnyUser()}.
+ *
+ * @see android.app.admin.DevicePolicyManager#isDeviceOwnerAppOnAnyUser
+ */
+ boolean isDeviceOwnerAppOnAnyUser(String packageName);
+
+ /**
+ * Calls {@code DevicePolicyManager.packageHasActiveAdmins()}.
+ *
+ * @see android.app.admin.DevicePolicyManager#packageHasActiveAdmins
+ */
+ boolean packageHasActiveAdmins(String packageName);
+
+ /**
+ * Calls {@code DevicePolicyManager.isUninstallInQueue()}.
+ *
+ * @see android.app.admin.DevicePolicyManager#isUninstallInQueue
+ */
+ boolean isUninstallInQueue(String packageName);
}
diff --git a/src/com/android/settings/enterprise/DevicePolicyManagerWrapperImpl.java b/src/com/android/settings/enterprise/DevicePolicyManagerWrapperImpl.java
index 18563b5..95a154b 100644
--- a/src/com/android/settings/enterprise/DevicePolicyManagerWrapperImpl.java
+++ b/src/com/android/settings/enterprise/DevicePolicyManagerWrapperImpl.java
@@ -101,4 +101,19 @@
public List<String> getOwnerInstalledCaCerts(@NonNull UserHandle user) {
return mDpm.getOwnerInstalledCaCerts(user);
}
+
+ @Override
+ public boolean isDeviceOwnerAppOnAnyUser(String packageName) {
+ return mDpm.isDeviceOwnerAppOnAnyUser(packageName);
+ }
+
+ @Override
+ public boolean packageHasActiveAdmins(String packageName) {
+ return mDpm.packageHasActiveAdmins(packageName);
+ }
+
+ @Override
+ public boolean isUninstallInQueue(String packageName) {
+ return mDpm.isUninstallInQueue(packageName);
+ }
}
diff --git a/src/com/android/settings/fuelgauge/AdvancedPowerUsageDetail.java b/src/com/android/settings/fuelgauge/AdvancedPowerUsageDetail.java
index 73cb5b5..8be3b14 100644
--- a/src/com/android/settings/fuelgauge/AdvancedPowerUsageDetail.java
+++ b/src/com/android/settings/fuelgauge/AdvancedPowerUsageDetail.java
@@ -16,11 +16,19 @@
package com.android.settings.fuelgauge;
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.app.Dialog;
+import android.app.admin.DevicePolicyManager;
import android.content.Context;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.content.pm.PackageManager;
import android.os.BatteryStats;
import android.os.Bundle;
import android.os.SystemClock;
import android.os.UserHandle;
+import android.os.UserManager;
import android.support.annotation.VisibleForTesting;
import android.support.v14.preference.PreferenceFragment;
import android.support.v7.preference.Preference;
@@ -36,6 +44,8 @@
import com.android.settings.applications.AppHeaderController;
import com.android.settings.applications.LayoutPreference;
import com.android.settings.core.PreferenceController;
+import com.android.settings.enterprise.DevicePolicyManagerWrapper;
+import com.android.settings.enterprise.DevicePolicyManagerWrapperImpl;
import com.android.settings.overlay.FeatureFactory;
import com.android.settingslib.applications.ApplicationsState;
@@ -50,7 +60,8 @@
*
* This fragment will replace {@link PowerUsageDetail}
*/
-public class AdvancedPowerUsageDetail extends PowerUsageBase {
+public class AdvancedPowerUsageDetail extends PowerUsageBase implements
+ ButtonActionDialogFragment.AppButtonsDialogListener {
public static final String TAG = "AdvancedPowerUsageDetail";
public static final String EXTRA_UID = "extra_uid";
@@ -67,6 +78,9 @@
private static final String KEY_PREF_POWER_USAGE = "app_power_usage";
private static final String KEY_PREF_HEADER = "header_view";
+ private static final int REQUEST_UNINSTALL = 0;
+ private static final int REQUEST_REMOVE_DEVICE_ADMIN = 1;
+
@VisibleForTesting
LayoutPreference mHeaderPreference;
@VisibleForTesting
@@ -77,6 +91,11 @@
private Preference mForegroundPreference;
private Preference mBackgroundPreference;
private Preference mPowerUsagePreference;
+ private AppButtonsPreferenceController mAppButtonsPreferenceController;
+
+ private DevicePolicyManagerWrapper mDpm;
+ private UserManager mUserManager;
+ private PackageManager mPackageManager;
public static void startBatteryDetailPage(SettingsActivity caller, PreferenceFragment fragment,
BatteryStatsHelper helper, int which, BatteryEntry entry, String usagePercent) {
@@ -113,6 +132,17 @@
}
@Override
+ public void onAttach(Activity activity) {
+ super.onAttach(activity);
+
+ mState = ApplicationsState.getInstance(getActivity().getApplication());
+ mDpm = new DevicePolicyManagerWrapperImpl(
+ (DevicePolicyManager) activity.getSystemService(Context.DEVICE_POLICY_SERVICE));
+ mUserManager = (UserManager) activity.getSystemService(Context.USER_SERVICE);
+ mPackageManager = activity.getPackageManager();
+ }
+
+ @Override
public void onCreate(Bundle icicle) {
super.onCreate(icicle);
@@ -120,7 +150,6 @@
mBackgroundPreference = findPreference(KEY_PREF_BACKGROUND);
mPowerUsagePreference = findPreference(KEY_PREF_POWER_USAGE);
mHeaderPreference = (LayoutPreference) findPreference(KEY_PREF_HEADER);
- mState = ApplicationsState.getInstance(getActivity().getApplication());
final String packageName = getArguments().getString(EXTRA_PACKAGE_NAME);
if (packageName != null) {
@@ -160,7 +189,13 @@
if (mAppEntry == null) {
controller.setLabel(bundle.getString(EXTRA_LABEL));
- controller.setIcon(getContext().getDrawable(bundle.getInt(EXTRA_ICON_ID)));
+
+ final int iconId = bundle.getInt(EXTRA_ICON_ID, 0);
+ if (iconId == 0) {
+ controller.setIcon(context.getPackageManager().getDefaultActivityIcon());
+ } else {
+ controller.setIcon(context.getDrawable(bundle.getInt(EXTRA_ICON_ID)));
+ }
} else {
mState.ensureIcon(mAppEntry);
controller.setLabel(mAppEntry);
@@ -196,9 +231,26 @@
controllers.add(new BackgroundActivityPreferenceController(context, uid));
controllers.add(new BatteryOptimizationPreferenceController(
(SettingsActivity) getActivity(), this));
- controllers.add(
- new AppButtonsPreferenceController(getActivity(), getLifecycle(), packageName));
+ mAppButtonsPreferenceController = new AppButtonsPreferenceController(
+ (SettingsActivity) getActivity(), this, getLifecycle(), packageName, mState, mDpm,
+ mUserManager, mPackageManager, REQUEST_UNINSTALL, REQUEST_REMOVE_DEVICE_ADMIN);
+ controllers.add(mAppButtonsPreferenceController);
return controllers;
}
+
+ @Override
+ public void onActivityResult(int requestCode, int resultCode, Intent data) {
+ super.onActivityResult(requestCode, resultCode, data);
+ if (mAppButtonsPreferenceController != null) {
+ mAppButtonsPreferenceController.handleActivityResult(requestCode, resultCode, data);
+ }
+ }
+
+ @Override
+ public void handleDialogClick(int id) {
+ if (mAppButtonsPreferenceController != null) {
+ mAppButtonsPreferenceController.handleDialogClick(id);
+ }
+ }
}
diff --git a/src/com/android/settings/fuelgauge/AppButtonsPreferenceController.java b/src/com/android/settings/fuelgauge/AppButtonsPreferenceController.java
index b02c8c5..f7cb191 100644
--- a/src/com/android/settings/fuelgauge/AppButtonsPreferenceController.java
+++ b/src/com/android/settings/fuelgauge/AppButtonsPreferenceController.java
@@ -17,42 +17,139 @@
package com.android.settings.fuelgauge;
import android.app.Activity;
+import android.app.ActivityManager;
+import android.app.Fragment;
+import android.content.BroadcastReceiver;
+import android.content.ComponentName;
+import android.content.Context;
+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.ResolveInfo;
+import android.content.pm.UserInfo;
+import android.content.res.Resources;
+import android.net.Uri;
+import android.os.AsyncTask;
+import android.os.Bundle;
+import android.os.RemoteException;
+import android.os.ServiceManager;
import android.os.UserHandle;
+import android.os.UserManager;
import android.support.v7.preference.PreferenceScreen;
+import android.util.Log;
import android.view.View;
+import android.webkit.IWebViewUpdateService;
import android.widget.Button;
+import com.android.internal.annotations.VisibleForTesting;
+import com.android.internal.logging.nano.MetricsProto;
+import com.android.settings.DeviceAdminAdd;
import com.android.settings.R;
+import com.android.settings.SettingsActivity;
+import com.android.settings.Utils;
import com.android.settings.applications.LayoutPreference;
import com.android.settings.core.PreferenceController;
+import com.android.settings.core.instrumentation.MetricsFeatureProvider;
import com.android.settings.core.lifecycle.Lifecycle;
import com.android.settings.core.lifecycle.LifecycleObserver;
+import com.android.settings.core.lifecycle.events.OnDestroy;
+import com.android.settings.core.lifecycle.events.OnPause;
import com.android.settings.core.lifecycle.events.OnResume;
+import com.android.settings.enterprise.DevicePolicyManagerWrapper;
+import com.android.settings.overlay.FeatureFactory;
+import com.android.settingslib.RestrictedLockUtils;
import com.android.settingslib.applications.ApplicationsState;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+
/**
- * Controller to control the uninstall button and forcestop button
+ * Controller to control the uninstall button and forcestop button. All fragments that use
+ * this controller should implement {@link ButtonActionDialogFragment.AppButtonsDialogListener} and
+ * handle {@link Fragment#onActivityResult(int, int, Intent)}
+ *
+ * An easy way to handle them is to delegate them to {@link #handleDialogClick(int)} and
+ * {@link #handleActivityResult(int, int, Intent)} in this controller.
*/
-//TODO(b/35810915): refine the button logic and make InstalledAppDetails use this controller
-//TODO(b/35810915): add test for this file
+//TODO(b/35810915): Make InstalledAppDetails use this controller
public class AppButtonsPreferenceController extends PreferenceController implements
- LifecycleObserver, OnResume {
+ LifecycleObserver, OnResume, OnPause, OnDestroy, View.OnClickListener,
+ ApplicationsState.Callbacks {
+ public static final String APP_CHG = "chg";
+
+ private static final String TAG = "AppButtonsPrefCtl";
private static final String KEY_ACTION_BUTTONS = "action_buttons";
+ private static final boolean LOCAL_LOGV = false;
- private ApplicationsState.AppEntry mAppEntry;
+ @VisibleForTesting
+ final HashSet<String> mHomePackages = new HashSet<>();
+ @VisibleForTesting
+ ApplicationsState mState;
+ @VisibleForTesting
+ ApplicationsState.AppEntry mAppEntry;
+ @VisibleForTesting
+ PackageInfo mPackageInfo;
+ @VisibleForTesting
+ Button mForceStopButton;
+ @VisibleForTesting
+ Button mUninstallButton;
+ @VisibleForTesting
+ boolean mDisableAfterUninstall = false;
+
+ private final int mRequestUninstall;
+ private final int mRequestRemoveDeviceAdmin;
+
+ private ApplicationsState.Session mSession;
+ private DevicePolicyManagerWrapper mDpm;
+ private UserManager mUserManager;
+ private PackageManager mPm;
+ private SettingsActivity mActivity;
+ private Fragment mFragment;
+ private RestrictedLockUtils.EnforcedAdmin mAppsControlDisallowedAdmin;
+ private MetricsFeatureProvider mMetricsFeatureProvider;
+
private LayoutPreference mButtonsPref;
- private Button mForceStopButton;
- private Button mUninstallButton;
+ private String mPackageName;
+ private int mUserId;
+ private boolean mUpdatedSysApp = false;
+ private boolean mListeningToPackageRemove = false;
+ private boolean mFinishing = false;
+ private boolean mAppsControlDisallowedBySystem;
- public AppButtonsPreferenceController(Activity activity, Lifecycle lifecycle,
- String packageName) {
+ public AppButtonsPreferenceController(SettingsActivity activity, Fragment fragment,
+ Lifecycle lifecycle, String packageName, ApplicationsState state,
+ DevicePolicyManagerWrapper dpm, UserManager userManager,
+ PackageManager packageManager, int requestUninstall, int requestRemoveDeviceAdmin) {
super(activity);
+ if (!(fragment instanceof ButtonActionDialogFragment.AppButtonsDialogListener)) {
+ throw new IllegalArgumentException(
+ "Fragment should implement AppButtonsDialogListener");
+ }
+
+ mMetricsFeatureProvider = FeatureFactory.getFactory(activity).getMetricsFeatureProvider();
+
+ mState = state;
+ mSession = mState.newSession(this);
+ mDpm = dpm;
+ mUserManager = userManager;
+ mPm = packageManager;
+ mPackageName = packageName;
+ mActivity = activity;
+ mFragment = fragment;
+ mUserId = UserHandle.myUserId();
+ mRequestUninstall = requestUninstall;
+ mRequestRemoveDeviceAdmin = requestRemoveDeviceAdmin;
+
lifecycle.addObserver(this);
- ApplicationsState state = ApplicationsState.getInstance(activity.getApplication());
if (packageName != null) {
- mAppEntry = state.getEntry(packageName, UserHandle.myUserId());
+ mAppEntry = mState.getEntry(packageName, mUserId);
+ } else {
+ mFinishing = true;
}
}
@@ -72,6 +169,7 @@
mForceStopButton = (Button) mButtonsPref.findViewById(R.id.right_button);
mForceStopButton.setText(R.string.force_stop);
+ mForceStopButton.setEnabled(false);
}
}
@@ -82,6 +180,524 @@
@Override
public void onResume() {
- //TODO(b/35810915): check and update the status of buttons
+ mSession.resume();
+ if (isAvailable() && !mFinishing) {
+ mAppsControlDisallowedBySystem = RestrictedLockUtils.hasBaseUserRestriction(mActivity,
+ UserManager.DISALLOW_APPS_CONTROL, mUserId);
+ mAppsControlDisallowedAdmin = RestrictedLockUtils.checkIfRestrictionEnforced(mActivity,
+ UserManager.DISALLOW_APPS_CONTROL, mUserId);
+
+ if (!refreshUi()) {
+ setIntentAndFinish(true);
+ }
+ }
}
+
+ @Override
+ public void onPause() {
+ mSession.pause();
+ }
+
+ @Override
+ public void onDestroy() {
+ stopListeningToPackageRemove();
+ mSession.release();
+ }
+
+ @Override
+ public void onClick(View v) {
+ final String packageName = mAppEntry.info.packageName;
+ final int id = v.getId();
+ if (id == R.id.left_button) {
+ // Uninstall
+ if (mDpm.packageHasActiveAdmins(mPackageInfo.packageName)) {
+ stopListeningToPackageRemove();
+ Intent uninstallDaIntent = new Intent(mActivity, DeviceAdminAdd.class);
+ uninstallDaIntent.putExtra(DeviceAdminAdd.EXTRA_DEVICE_ADMIN_PACKAGE_NAME,
+ packageName);
+ mMetricsFeatureProvider.action(mActivity,
+ MetricsProto.MetricsEvent.ACTION_SETTINGS_UNINSTALL_DEVICE_ADMIN);
+ mFragment.startActivityForResult(uninstallDaIntent, mRequestRemoveDeviceAdmin);
+ return;
+ }
+ RestrictedLockUtils.EnforcedAdmin admin =
+ RestrictedLockUtils.checkIfUninstallBlocked(mActivity,
+ packageName, mUserId);
+ boolean uninstallBlockedBySystem = mAppsControlDisallowedBySystem ||
+ RestrictedLockUtils.hasBaseUserRestriction(mActivity, packageName, mUserId);
+ if (admin != null && !uninstallBlockedBySystem) {
+ RestrictedLockUtils.sendShowAdminSupportDetailsIntent(mActivity, 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(ButtonActionDialogFragment.DialogType.SPECIAL_DISABLE);
+ } else {
+ showDialogInner(ButtonActionDialogFragment.DialogType.DISABLE);
+ }
+ } else {
+ mMetricsFeatureProvider.action(
+ mActivity,
+ mAppEntry.info.enabled
+ ? MetricsProto.MetricsEvent.ACTION_SETTINGS_DISABLE_APP
+ : MetricsProto.MetricsEvent.ACTION_SETTINGS_ENABLE_APP);
+ AsyncTask.execute(new DisableChangerRunnable(mPm, mAppEntry.info.packageName,
+ PackageManager.COMPONENT_ENABLED_STATE_DEFAULT));
+ }
+ } else if ((mAppEntry.info.flags & ApplicationInfo.FLAG_INSTALLED) == 0) {
+ uninstallPkg(packageName, true, false);
+ } else {
+ uninstallPkg(packageName, false, false);
+ }
+ } else if (id == R.id.right_button) {
+ // force stop
+ if (mAppsControlDisallowedAdmin != null && !mAppsControlDisallowedBySystem) {
+ RestrictedLockUtils.sendShowAdminSupportDetailsIntent(
+ mActivity, mAppsControlDisallowedAdmin);
+ } else {
+ showDialogInner(ButtonActionDialogFragment.DialogType.FORCE_STOP);
+ }
+ }
+ }
+
+ public void handleActivityResult(int requestCode, int resultCode, Intent data) {
+ if (requestCode == mRequestUninstall) {
+ if (mDisableAfterUninstall) {
+ mDisableAfterUninstall = false;
+ AsyncTask.execute(new DisableChangerRunnable(mPm, mAppEntry.info.packageName,
+ PackageManager.COMPONENT_ENABLED_STATE_DISABLED_USER));
+ }
+ refreshAndFinishIfPossible();
+ } else if (requestCode == mRequestRemoveDeviceAdmin) {
+ refreshAndFinishIfPossible();
+ }
+ }
+
+ public void handleDialogClick(int id) {
+ switch (id) {
+ case ButtonActionDialogFragment.DialogType.DISABLE:
+ mMetricsFeatureProvider.action(mActivity,
+ MetricsProto.MetricsEvent.ACTION_SETTINGS_DISABLE_APP);
+ AsyncTask.execute(new DisableChangerRunnable(mPm, mAppEntry.info.packageName,
+ PackageManager.COMPONENT_ENABLED_STATE_DISABLED_USER));
+ break;
+ case ButtonActionDialogFragment.DialogType.SPECIAL_DISABLE:
+ mMetricsFeatureProvider.action(mActivity,
+ MetricsProto.MetricsEvent.ACTION_SETTINGS_DISABLE_APP);
+ uninstallPkg(mAppEntry.info.packageName, false, true);
+ break;
+ case ButtonActionDialogFragment.DialogType.FORCE_STOP:
+ forceStopPackage(mAppEntry.info.packageName);
+ break;
+ }
+ }
+
+ @Override
+ public void onRunningStateChanged(boolean running) {
+
+ }
+
+ @Override
+ public void onPackageListChanged() {
+ refreshUi();
+ }
+
+ @Override
+ public void onRebuildComplete(ArrayList<ApplicationsState.AppEntry> apps) {
+
+ }
+
+ @Override
+ public void onPackageIconChanged() {
+
+ }
+
+ @Override
+ public void onPackageSizeChanged(String packageName) {
+
+ }
+
+ @Override
+ public void onAllSizesComputed() {
+
+ }
+
+ @Override
+ public void onLauncherInfoChanged() {
+
+ }
+
+ @Override
+ public void onLoadEntriesCompleted() {
+
+ }
+
+ @VisibleForTesting
+ void retrieveAppEntry() {
+ mAppEntry = mState.getEntry(mPackageName, mUserId);
+ if (mAppEntry != null) {
+ try {
+ mPackageInfo = mPm.getPackageInfo(mAppEntry.info.packageName,
+ PackageManager.MATCH_DISABLED_COMPONENTS |
+ PackageManager.MATCH_ANY_USER |
+ PackageManager.GET_SIGNATURES |
+ PackageManager.GET_PERMISSIONS);
+
+ mPackageName = mAppEntry.info.packageName;
+ } catch (PackageManager.NameNotFoundException e) {
+ Log.e(TAG, "Exception when retrieving package:" + mAppEntry.info.packageName, e);
+ mPackageInfo = null;
+ }
+ } else {
+ mPackageInfo = null;
+ }
+ }
+
+ @VisibleForTesting
+ void updateUninstallButton() {
+ final boolean isBundled = (mAppEntry.info.flags & ApplicationInfo.FLAG_SYSTEM) != 0;
+ boolean enabled = true;
+ if (isBundled) {
+ enabled = handleDisableable(mUninstallButton);
+ } else {
+ if ((mPackageInfo.applicationInfo.flags & ApplicationInfo.FLAG_INSTALLED) == 0
+ && mUserManager.getUsers().size() >= 2) {
+ // When we have multiple users, there is a separate menu
+ // to uninstall for all users.
+ enabled = false;
+ }
+ }
+ // If this is a device admin, it can't be uninstalled or disabled.
+ // We do this here so the text of the button is still set correctly.
+ if (isBundled && mDpm.packageHasActiveAdmins(mPackageInfo.packageName)) {
+ enabled = false;
+ }
+
+ // We don't allow uninstalling DO/PO on *any* users, because if it's a system app,
+ // "uninstall" is actually "downgrade to the system version + disable", and "downgrade"
+ // will clear data on all users.
+ if (isProfileOrDeviceOwner(mPackageInfo.packageName)) {
+ enabled = false;
+ }
+
+ // Don't allow uninstalling the device provisioning package.
+ if (Utils.isDeviceProvisioningPackage(mContext.getResources(),
+ mAppEntry.info.packageName)) {
+ enabled = false;
+ }
+
+ // If the uninstall intent is already queued, disable the uninstall button
+ if (mDpm.isUninstallInQueue(mPackageName)) {
+ enabled = false;
+ }
+
+ // Home apps need special handling. Bundled ones we don't risk downgrading
+ // because that can interfere with home-key resolution. Furthermore, we
+ // can't allow uninstallation of the only home app, and we don't want to
+ // allow uninstallation of an explicitly preferred one -- the user can go
+ // to Home settings and pick a different one, after which we'll permit
+ // uninstallation of the now-not-default one.
+ if (enabled && mHomePackages.contains(mPackageInfo.packageName)) {
+ if (isBundled) {
+ enabled = false;
+ } else {
+ ArrayList<ResolveInfo> homeActivities = new ArrayList<ResolveInfo>();
+ ComponentName currentDefaultHome = mPm.getHomeActivities(homeActivities);
+ if (currentDefaultHome == null) {
+ // No preferred default, so permit uninstall only when
+ // there is more than one candidate
+ enabled = (mHomePackages.size() > 1);
+ } else {
+ // There is an explicit default home app -- forbid uninstall of
+ // that one, but permit it for installed-but-inactive ones.
+ enabled = !mPackageInfo.packageName.equals(currentDefaultHome.getPackageName());
+ }
+ }
+ }
+
+ if (mAppsControlDisallowedBySystem) {
+ enabled = false;
+ }
+
+ if (isFallbackPackage(mAppEntry.info.packageName)) {
+ enabled = false;
+ }
+
+ mUninstallButton.setEnabled(enabled);
+ if (enabled) {
+ // Register listener
+ mUninstallButton.setOnClickListener(this);
+ }
+ }
+
+ /**
+ * Finish this fragment and return data if possible
+ */
+ private void setIntentAndFinish(boolean appChanged) {
+ if (LOCAL_LOGV) {
+ Log.i(TAG, "appChanged=" + appChanged);
+ }
+ Intent intent = new Intent();
+ intent.putExtra(APP_CHG, appChanged);
+ mActivity.finishPreferencePanel(mFragment, Activity.RESULT_OK, intent);
+ mFinishing = true;
+ }
+
+ private void refreshAndFinishIfPossible() {
+ if (!refreshUi()) {
+ setIntentAndFinish(true);
+ } else {
+ startListeningToPackageRemove();
+ }
+ }
+
+ @VisibleForTesting
+ boolean isFallbackPackage(String packageName) {
+ try {
+ IWebViewUpdateService webviewUpdateService =
+ IWebViewUpdateService.Stub.asInterface(
+ ServiceManager.getService("webviewupdate"));
+ if (webviewUpdateService.isFallbackPackage(packageName)) {
+ return true;
+ }
+ } catch (RemoteException e) {
+ throw new RuntimeException(e);
+ }
+
+ return false;
+ }
+
+ @VisibleForTesting
+ void updateForceStopButton() {
+ if (mDpm.packageHasActiveAdmins(mPackageInfo.packageName)) {
+ // User can't force stop device admin.
+ Log.w(TAG, "User can't force stop device admin");
+ updateForceStopButtonInner(false);
+ } else if ((mAppEntry.info.flags & ApplicationInfo.FLAG_STOPPED) == 0) {
+ // If the app isn't explicitly stopped, then always show the
+ // force stop button.
+ Log.w(TAG, "App is not explicitly stopped");
+ updateForceStopButtonInner(true);
+ } else {
+ Intent intent = new Intent(Intent.ACTION_QUERY_PACKAGE_RESTART,
+ Uri.fromParts("package", mAppEntry.info.packageName, null));
+ intent.putExtra(Intent.EXTRA_PACKAGES, new String[]{mAppEntry.info.packageName});
+ intent.putExtra(Intent.EXTRA_UID, mAppEntry.info.uid);
+ intent.putExtra(Intent.EXTRA_USER_HANDLE, UserHandle.getUserId(mAppEntry.info.uid));
+ Log.d(TAG, "Sending broadcast to query restart status for "
+ + mAppEntry.info.packageName);
+ mActivity.sendOrderedBroadcastAsUser(intent, UserHandle.CURRENT, null,
+ mCheckKillProcessesReceiver, null, Activity.RESULT_CANCELED, null, null);
+ }
+ }
+
+ @VisibleForTesting
+ void updateForceStopButtonInner(boolean enabled) {
+ if (mAppsControlDisallowedBySystem) {
+ mForceStopButton.setEnabled(false);
+ } else {
+ mForceStopButton.setEnabled(enabled);
+ mForceStopButton.setOnClickListener(this);
+ }
+ }
+
+ @VisibleForTesting
+ void uninstallPkg(String packageName, boolean allUsers, boolean andDisable) {
+ stopListeningToPackageRemove();
+ // Create new intent to launch Uninstaller activity
+ Uri packageUri = Uri.parse("package:" + packageName);
+ Intent uninstallIntent = new Intent(Intent.ACTION_UNINSTALL_PACKAGE, packageUri);
+ uninstallIntent.putExtra(Intent.EXTRA_UNINSTALL_ALL_USERS, allUsers);
+
+ mMetricsFeatureProvider.action(
+ mActivity, MetricsProto.MetricsEvent.ACTION_SETTINGS_UNINSTALL_APP);
+ mFragment.startActivityForResult(uninstallIntent, mRequestUninstall);
+ mDisableAfterUninstall = andDisable;
+ }
+
+ @VisibleForTesting
+ void forceStopPackage(String pkgName) {
+ FeatureFactory.getFactory(mContext).getMetricsFeatureProvider().action(mContext,
+ MetricsProto.MetricsEvent.ACTION_APP_FORCE_STOP, pkgName);
+ ActivityManager am = (ActivityManager) mActivity.getSystemService(
+ Context.ACTIVITY_SERVICE);
+ Log.d(TAG, "Stopping package " + pkgName);
+ am.forceStopPackage(pkgName);
+ int userId = UserHandle.getUserId(mAppEntry.info.uid);
+ mState.invalidatePackage(pkgName, userId);
+ ApplicationsState.AppEntry newEnt = mState.getEntry(pkgName, userId);
+ if (newEnt != null) {
+ mAppEntry = newEnt;
+ }
+ updateForceStopButton();
+ }
+
+ @VisibleForTesting
+ boolean handleDisableable(Button button) {
+ boolean disableable = false;
+ // Try to prevent the user from bricking their phone
+ // by not allowing disabling of apps signed with the
+ // system cert and any launcher app in the system.
+ if (mHomePackages.contains(mAppEntry.info.packageName)
+ || isSystemPackage(mActivity.getResources(), mPm, mPackageInfo)) {
+ // Disable button for core system applications.
+ button.setText(R.string.disable_text);
+ } else if (mAppEntry.info.enabled && !isDisabledUntilUsed()) {
+ button.setText(R.string.disable_text);
+ disableable = true;
+ } else {
+ button.setText(R.string.enable_text);
+ disableable = true;
+ }
+
+ return disableable;
+ }
+
+ @VisibleForTesting
+ boolean isSystemPackage(Resources resources, PackageManager pm, PackageInfo packageInfo) {
+ return Utils.isSystemPackage(resources, pm, packageInfo);
+ }
+
+ private boolean isDisabledUntilUsed() {
+ return mAppEntry.info.enabledSetting
+ == PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED;
+ }
+
+ private void showDialogInner(@ButtonActionDialogFragment.DialogType int id) {
+ ButtonActionDialogFragment newFragment = ButtonActionDialogFragment.newInstance(id);
+ newFragment.setTargetFragment(mFragment, 0);
+ newFragment.show(mActivity.getFragmentManager(), "dialog " + id);
+ }
+
+ /** 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);
+ }
+
+ /** Returns if the supplied package is device owner or profile owner of at least one user */
+ private boolean isProfileOrDeviceOwner(String packageName) {
+ List<UserInfo> userInfos = mUserManager.getUsers();
+ if (mDpm.isDeviceOwnerAppOnAnyUser(packageName)) {
+ return true;
+ }
+ for (int i = 0, size = userInfos.size(); i < size; i++) {
+ ComponentName cn = mDpm.getProfileOwnerAsUser(userInfos.get(i).id);
+ if (cn != null && cn.getPackageName().equals(packageName)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private final BroadcastReceiver mCheckKillProcessesReceiver = new BroadcastReceiver() {
+ @Override
+ public void onReceive(Context context, Intent intent) {
+ final boolean enabled = getResultCode() != Activity.RESULT_CANCELED;
+ Log.d(TAG, "Got broadcast response: Restart status for "
+ + mAppEntry.info.packageName + " " + enabled);
+ updateForceStopButtonInner(enabled);
+ }
+ };
+
+ private boolean signaturesMatch(String pkg1, String pkg2) {
+ if (pkg1 != null && pkg2 != null) {
+ try {
+ final int match = mPm.checkSignatures(pkg1, pkg2);
+ if (match >= PackageManager.SIGNATURE_MATCH) {
+ return true;
+ }
+ } catch (Exception e) {
+ // e.g. named alternate package not found during lookup;
+ // this is an expected case sometimes
+ }
+ }
+ return false;
+ }
+
+ private boolean refreshUi() {
+ retrieveAppEntry();
+ if (mAppEntry == null || mPackageInfo == null) {
+ return false;
+ }
+ // Get list of "home" apps and trace through any meta-data references
+ List<ResolveInfo> homeActivities = new ArrayList<>();
+ mPm.getHomeActivities(homeActivities);
+ mHomePackages.clear();
+ for (int i = 0, size = homeActivities.size(); i < size; i++) {
+ ResolveInfo ri = homeActivities.get(i);
+ final String activityPkg = ri.activityInfo.packageName;
+ mHomePackages.add(activityPkg);
+
+ // Also make sure to include anything proxying for the home app
+ final Bundle metadata = ri.activityInfo.metaData;
+ if (metadata != null) {
+ final String metaPkg = metadata.getString(ActivityManager.META_HOME_ALTERNATE);
+ if (signaturesMatch(metaPkg, activityPkg)) {
+ mHomePackages.add(metaPkg);
+ }
+ }
+ }
+
+ updateUninstallButton();
+ updateForceStopButton();
+
+ return true;
+ }
+
+ private void startListeningToPackageRemove() {
+ if (mListeningToPackageRemove) {
+ return;
+ }
+ mListeningToPackageRemove = true;
+ final IntentFilter filter = new IntentFilter(Intent.ACTION_PACKAGE_REMOVED);
+ filter.addDataScheme("package");
+ mActivity.registerReceiver(mPackageRemovedReceiver, filter);
+ }
+
+ private void stopListeningToPackageRemove() {
+ if (!mListeningToPackageRemove) {
+ return;
+ }
+ mListeningToPackageRemove = false;
+ mActivity.unregisterReceiver(mPackageRemovedReceiver);
+ }
+
+
+ /**
+ * Changes the status of disable/enable for a package
+ */
+ private class DisableChangerRunnable implements Runnable {
+ final PackageManager mPm;
+ final String mPackageName;
+ final int mState;
+
+ public DisableChangerRunnable(PackageManager pm, String packageName, int state) {
+ mPm = pm;
+ mPackageName = packageName;
+ mState = state;
+ }
+
+ @Override
+ public void run() {
+ mPm.setApplicationEnabledSetting(mPackageName, mState, 0);
+ }
+ }
+
+ /**
+ * Receiver to listen to the remove action for packages
+ */
+ private final BroadcastReceiver mPackageRemovedReceiver = new BroadcastReceiver() {
+ @Override
+ public void onReceive(Context context, Intent intent) {
+ String packageName = intent.getData().getSchemeSpecificPart();
+ if (!mFinishing && mAppEntry.info.packageName.equals(packageName)) {
+ mActivity.finishAndRemoveTask();
+ }
+ }
+ };
+
}
diff --git a/src/com/android/settings/fuelgauge/ButtonActionDialogFragment.java b/src/com/android/settings/fuelgauge/ButtonActionDialogFragment.java
new file mode 100644
index 0000000..b17cd54
--- /dev/null
+++ b/src/com/android/settings/fuelgauge/ButtonActionDialogFragment.java
@@ -0,0 +1,104 @@
+package com.android.settings.fuelgauge;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.app.Dialog;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.os.Bundle;
+import android.support.annotation.IntDef;
+import android.support.annotation.VisibleForTesting;
+
+import com.android.internal.logging.nano.MetricsProto;
+import com.android.settings.R;
+import com.android.settings.core.instrumentation.InstrumentedDialogFragment;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/**
+ * Fragment to show the dialog for uninstall or forcestop. This fragment uses function in
+ * target fragment to handle the dialog button click.
+ */
+public class ButtonActionDialogFragment extends InstrumentedDialogFragment implements
+ DialogInterface.OnClickListener {
+
+ /**
+ * Interface to handle the dialog click
+ */
+ interface AppButtonsDialogListener {
+ void handleDialogClick(int type);
+ }
+
+ @Retention(RetentionPolicy.SOURCE)
+ @IntDef({
+ DialogType.DISABLE,
+ DialogType.SPECIAL_DISABLE,
+ DialogType.FORCE_STOP
+ })
+ public @interface DialogType {
+ int DISABLE = 0;
+ int SPECIAL_DISABLE = 1;
+ int FORCE_STOP = 2;
+ }
+
+ private static final String ARG_ID = "id";
+ @VisibleForTesting
+ int mId;
+
+ public static ButtonActionDialogFragment newInstance(@DialogType int id) {
+ ButtonActionDialogFragment dialogFragment = new ButtonActionDialogFragment();
+ Bundle args = new Bundle(1);
+ args.putInt(ARG_ID, id);
+ dialogFragment.setArguments(args);
+
+ return dialogFragment;
+ }
+
+ @Override
+ public int getMetricsCategory() {
+ //TODO(35810915): update the metrics label because for now this fragment will be shown
+ // in two screens
+ return MetricsProto.MetricsEvent.DIALOG_APP_INFO_ACTION;
+ }
+
+ @Override
+ public Dialog onCreateDialog(Bundle savedInstanceState) {
+ final Bundle bundle = getArguments();
+ mId = bundle.getInt(ARG_ID);
+ Dialog dialog = createDialog(mId);
+ if (dialog == null) {
+ throw new IllegalArgumentException("unknown id " + mId);
+ }
+ return dialog;
+ }
+
+ @Override
+ public void onClick(DialogInterface dialog, int which) {
+ final AppButtonsDialogListener lsn =
+ (AppButtonsDialogListener) getTargetFragment();
+ lsn.handleDialogClick(mId);
+ }
+
+ private AlertDialog createDialog(int id) {
+ final Context context = getContext();
+ switch (id) {
+ case DialogType.DISABLE:
+ case DialogType.SPECIAL_DISABLE:
+ return new AlertDialog.Builder(context)
+ .setMessage(R.string.app_disable_dlg_text)
+ .setPositiveButton(R.string.app_disable_dlg_positive, this)
+ .setNegativeButton(R.string.dlg_cancel, null)
+ .create();
+ case DialogType.FORCE_STOP:
+ return new AlertDialog.Builder(context)
+ .setTitle(R.string.force_stop_dlg_title)
+ .setMessage(R.string.force_stop_dlg_text)
+ .setPositiveButton(R.string.dlg_ok, this)
+ .setNegativeButton(R.string.dlg_cancel, null)
+ .create();
+ }
+ return null;
+ }
+}
+
diff --git a/src/com/android/settings/fuelgauge/PowerUsageAdvanced.java b/src/com/android/settings/fuelgauge/PowerUsageAdvanced.java
index 93e7810..fe0cf4d 100644
--- a/src/com/android/settings/fuelgauge/PowerUsageAdvanced.java
+++ b/src/com/android/settings/fuelgauge/PowerUsageAdvanced.java
@@ -13,22 +13,29 @@
*/
package com.android.settings.fuelgauge;
+import android.app.Activity;
import android.content.Context;
import android.content.pm.PackageManager;
import android.os.BatteryStats;
import android.os.Bundle;
+import android.os.Handler;
+import android.os.Message;
+import android.os.UserManager;
import android.provider.SearchIndexableResource;
import android.support.annotation.ColorInt;
import android.support.annotation.IntDef;
import android.support.annotation.NonNull;
import android.support.annotation.StringRes;
import android.support.annotation.VisibleForTesting;
+import android.support.v7.preference.Preference;
import android.support.v7.preference.PreferenceGroup;
+
import com.android.internal.logging.nano.MetricsProto;
import com.android.internal.os.BatterySipper;
import com.android.internal.os.BatterySipper.DrainType;
import com.android.internal.os.BatteryStatsHelper;
import com.android.settings.R;
+import com.android.settings.Utils;
import com.android.settings.core.PreferenceController;
import com.android.settings.fuelgauge.PowerUsageAdvanced.PowerUsageData.UsageType;
import com.android.settings.overlay.FeatureFactory;
@@ -64,6 +71,38 @@
private PreferenceGroup mUsageListGroup;
private PowerUsageFeatureProvider mPowerUsageFeatureProvider;
private PackageManager mPackageManager;
+ private UserManager mUserManager;
+ private Map<Integer, PowerUsageData> mBatteryDataMap;
+
+ Handler mHandler = new Handler() {
+
+ @Override
+ public void handleMessage(Message msg) {
+ switch (msg.what) {
+ case BatteryEntry.MSG_UPDATE_NAME_ICON:
+ final int dischargeAmount = mStatsHelper.getStats().getDischargeAmount(
+ STATUS_TYPE);
+ final double totalPower = mStatsHelper.getTotalPower();
+ final BatteryEntry entry = (BatteryEntry) msg.obj;
+ final int usageType = extractUsageType(entry.sipper);
+
+ PowerUsageData usageData = mBatteryDataMap.get(usageType);
+ Preference pref = findPreference(String.valueOf(usageType));
+ if (pref != null && usageData != null) {
+ updateUsageDataSummary(usageData, totalPower, dischargeAmount);
+ pref.setSummary(usageData.summary);
+ }
+ break;
+ case BatteryEntry.MSG_REPORT_FULLY_DRAWN:
+ Activity activity = getActivity();
+ if (activity != null) {
+ activity.reportFullyDrawn();
+ }
+ break;
+ }
+ super.handleMessage(msg);
+ }
+ };
@Override
public void onCreate(Bundle icicle) {
@@ -76,6 +115,7 @@
mPowerUsageFeatureProvider = FeatureFactory.getFactory(context)
.getPowerUsageFeatureProvider(context);
mPackageManager = context.getPackageManager();
+ mUserManager = (UserManager) context.getSystemService(Context.USER_SERVICE);
}
@Override
@@ -85,6 +125,21 @@
}
@Override
+ public void onPause() {
+ BatteryEntry.stopRequestQueue();
+ mHandler.removeMessages(BatteryEntry.MSG_UPDATE_NAME_ICON);
+ super.onPause();
+ }
+
+ @Override
+ public void onDestroy() {
+ super.onDestroy();
+ if (getActivity().isChangingConfigurations()) {
+ BatteryEntry.clearUidCache();
+ }
+ }
+
+ @Override
public int getMetricsCategory() {
return MetricsProto.MetricsEvent.FUELGAUGE_BATTERY_HISTORY_DETAIL;
}
@@ -116,15 +171,19 @@
final PowerUsageData batteryData = dataList.get(i);
final PowerGaugePreference pref = new PowerGaugePreference(getPrefContext());
+ pref.setKey(String.valueOf(batteryData.usageType));
pref.setTitle(batteryData.titleResId);
pref.setSummary(batteryData.summary);
pref.setPercent(batteryData.percentage);
mUsageListGroup.addPreference(pref);
}
+
+ BatteryEntry.startRequestQueue();
}
@VisibleForTesting
- @UsageType int extractUsageType(BatterySipper sipper) {
+ @UsageType
+ int extractUsageType(BatterySipper sipper) {
final DrainType drainType = sipper.drainType;
final int uid = sipper.getUid();
@@ -163,22 +222,57 @@
sipper.mPackages = mPackageManager.getPackagesForUid(sipper.getUid());
final PowerUsageData usageData = batteryDataMap.get(extractUsageType(sipper));
usageData.totalPowerMah += sipper.totalPowerMah;
+ if (sipper.drainType == DrainType.APP && sipper.usageTimeMs != 0) {
+ sipper.usageTimeMs = BatteryUtils.getProcessTimeMs(BatteryUtils.StatusType.ALL,
+ sipper.uidObj, STATUS_TYPE);
+ }
+ usageData.totalUsageTimeMs += sipper.usageTimeMs;
+ usageData.usageList.add(sipper);
}
- // TODO(b/35396770): add logic to extract the summary
final List<PowerUsageData> batteryDataList = new ArrayList<>(batteryDataMap.values());
final int dischargeAmount = statusHelper.getStats().getDischargeAmount(STATUS_TYPE);
final double totalPower = statusHelper.getTotalPower();
for (final PowerUsageData usageData : batteryDataList) {
usageData.percentage = (usageData.totalPowerMah / totalPower) * dischargeAmount;
+ updateUsageDataSummary(usageData, totalPower, dischargeAmount);
}
Collections.sort(batteryDataList);
+ mBatteryDataMap = batteryDataMap;
return batteryDataList;
}
@VisibleForTesting
+ void updateUsageDataSummary(PowerUsageData usageData, double totalPower, int dischargeAmount) {
+ if (usageData.usageList.size() <= 1) {
+ usageData.summary = getString(R.string.battery_used_for,
+ Utils.formatElapsedTime(getContext(), usageData.totalUsageTimeMs, false));
+ } else {
+ BatterySipper sipper = findBatterySipperWithMaxBatteryUsage(usageData.usageList);
+ BatteryEntry batteryEntry = new BatteryEntry(getContext(), mHandler, mUserManager,
+ sipper);
+ final double percentage = (sipper.totalPowerMah / totalPower) * dischargeAmount;
+ usageData.summary = getString(R.string.battery_used_by,
+ Utils.formatPercentage(percentage, true), batteryEntry.name);
+ }
+ }
+
+ @VisibleForTesting
+ BatterySipper findBatterySipperWithMaxBatteryUsage(List<BatterySipper> usageList) {
+ BatterySipper sipper = usageList.get(0);
+ for (int i = 1, size = usageList.size(); i < size; i++) {
+ final BatterySipper comparedSipper = usageList.get(i);
+ if (comparedSipper.totalPowerMah > sipper.totalPowerMah) {
+ sipper = comparedSipper;
+ }
+ }
+
+ return sipper;
+ }
+
+ @VisibleForTesting
void setPackageManager(PackageManager packageManager) {
mPackageManager = packageManager;
}
@@ -221,10 +315,12 @@
public String summary;
public double percentage;
public double totalPowerMah;
+ public long totalUsageTimeMs;
@ColorInt
public int iconColor;
@UsageType
public int usageType;
+ public List<BatterySipper> usageList;
public PowerUsageData(@UsageType int usageType) {
this(usageType, 0);
@@ -233,8 +329,10 @@
public PowerUsageData(@UsageType int usageType, double totalPower) {
this.usageType = usageType;
totalPowerMah = 0;
+ totalUsageTimeMs = 0;
titleResId = getTitleResId(usageType);
totalPowerMah = totalPower;
+ usageList = new ArrayList<>();
}
private int getTitleResId(@UsageType int usageType) {
diff --git a/src/com/android/settings/fuelgauge/PowerUsageFeatureProviderImpl.java b/src/com/android/settings/fuelgauge/PowerUsageFeatureProviderImpl.java
index b8c40fd..10ffc49 100644
--- a/src/com/android/settings/fuelgauge/PowerUsageFeatureProviderImpl.java
+++ b/src/com/android/settings/fuelgauge/PowerUsageFeatureProviderImpl.java
@@ -27,8 +27,9 @@
private static final String PACKAGE_CALENDAR_PROVIDER = "com.android.providers.calendar";
private static final String PACKAGE_MEDIA_PROVIDER = "com.android.providers.media";
+ private static final String PACKAGE_SYSTEMUI = "com.android.systemui";
private static final String[] PACKAGES_SYSTEM = {PACKAGE_MEDIA_PROVIDER,
- PACKAGE_CALENDAR_PROVIDER};
+ PACKAGE_CALENDAR_PROVIDER, PACKAGE_SYSTEMUI};
protected PackageManager mPackageManager;
diff --git a/src/com/android/settings/fuelgauge/PowerUsageSummary.java b/src/com/android/settings/fuelgauge/PowerUsageSummary.java
index b0e8fb0..96141f9 100644
--- a/src/com/android/settings/fuelgauge/PowerUsageSummary.java
+++ b/src/com/android/settings/fuelgauge/PowerUsageSummary.java
@@ -489,6 +489,10 @@
pref.setTitle(entry.getLabel());
pref.setOrder(i + 1);
pref.setPercent(percentOfTotal);
+ if (sipper.usageTimeMs == 0 && sipper.drainType == DrainType.APP) {
+ sipper.usageTimeMs = BatteryUtils.getProcessTimeMs(
+ BatteryUtils.StatusType.FOREGROUND, sipper.uidObj, mStatsType);
+ }
setUsageSummary(pref, usedTime, sipper.usageTimeMs);
if ((sipper.drainType != DrainType.APP
|| sipper.uidObj.getUid() == Process.ROOT_UID)
@@ -594,8 +598,11 @@
boolean shouldHideSipper(BatterySipper sipper) {
final DrainType drainType = sipper.drainType;
- return drainType == DrainType.IDLE || drainType == DrainType.CELL
- || drainType == DrainType.SCREEN || drainType == DrainType.BLUETOOTH
+ return drainType == DrainType.IDLE
+ || drainType == DrainType.CELL
+ || drainType == DrainType.WIFI
+ || drainType == DrainType.SCREEN
+ || drainType == DrainType.BLUETOOTH
|| (sipper.totalPowerMah * SECONDS_IN_HOUR) < MIN_POWER_THRESHOLD_MILLI_AMP
|| mPowerFeatureProvider.isTypeService(sipper)
|| mPowerFeatureProvider.isTypeSystem(sipper);
diff --git a/tests/robotests/src/com/android/settings/fuelgauge/AppButtonsPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/fuelgauge/AppButtonsPreferenceControllerTest.java
new file mode 100644
index 0000000..85b4f81
--- /dev/null
+++ b/tests/robotests/src/com/android/settings/fuelgauge/AppButtonsPreferenceControllerTest.java
@@ -0,0 +1,330 @@
+/*
+ * 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.fuelgauge;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyString;
+import static org.mockito.Matchers.anyInt;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import android.app.ActivityManager;
+import android.app.Application;
+import android.app.Fragment;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
+import android.os.UserManager;
+import android.widget.Button;
+
+import com.android.settings.R;
+import com.android.settings.SettingsActivity;
+import com.android.settings.TestConfig;
+import com.android.settings.core.lifecycle.Lifecycle;
+import com.android.settings.enterprise.DevicePolicyManagerWrapper;
+import com.android.settings.testutils.FakeFeatureFactory;
+import com.android.settingslib.applications.ApplicationsState;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Answers;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+import org.robolectric.RobolectricTestRunner;
+import org.robolectric.annotation.Config;
+
+@RunWith(RobolectricTestRunner.class)
+@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
+public class AppButtonsPreferenceControllerTest {
+ private static final String PACKAGE_NAME = "com.android.settings";
+ private static final String RESOURCE_STRING = "string";
+ private static final boolean ALL_USERS = false;
+ private static final boolean DISABLE_AFTER_INSTALL = true;
+ private static final int REQUEST_UNINSTALL = 0;
+ private static final int REQUEST_REMOVE_DEVICE_ADMIN = 1;
+ @Mock(answer = Answers.RETURNS_DEEP_STUBS)
+ private SettingsActivity mSettingsActivity;
+ @Mock
+ private TestFragment mFragment;
+ @Mock
+ private Lifecycle mLifecycle;
+ @Mock
+ private ApplicationsState mState;
+ @Mock
+ private ApplicationsState.AppEntry mAppEntry;
+ @Mock
+ private ApplicationInfo mAppInfo;
+ @Mock
+ private PackageManager mPackageManger;
+ @Mock
+ private DevicePolicyManagerWrapper mDpm;
+ @Mock
+ private ActivityManager mAm;
+ @Mock
+ private UserManager mUserManager;
+ @Mock
+ private Application mApplication;
+ @Mock
+ private PackageInfo mPackageInfo;
+ @Mock
+ private Button mUninstallButton;
+ @Mock
+ private Button mForceStopButton;
+
+ private Intent mUninstallIntent;
+ private AppButtonsPreferenceController mController;
+
+ @Before
+ public void setUp() throws Exception {
+ MockitoAnnotations.initMocks(this);
+
+ FakeFeatureFactory.setupForTest(mSettingsActivity);
+ doReturn(mUserManager).when(mSettingsActivity).getSystemService(Context.USER_SERVICE);
+ doReturn(mPackageManger).when(mSettingsActivity).getPackageManager();
+ doReturn(mAm).when(mSettingsActivity).getSystemService(Context.ACTIVITY_SERVICE);
+ doReturn(mAppEntry).when(mState).getEntry(anyString(), anyInt());
+ doReturn(mApplication).when(mSettingsActivity).getApplication();
+ when(mSettingsActivity.getResources().getString(anyInt())).thenReturn(RESOURCE_STRING);
+
+ mController = spy(new AppButtonsPreferenceController(mSettingsActivity, mFragment,
+ mLifecycle, PACKAGE_NAME, mState, mDpm, mUserManager, mPackageManger,
+ REQUEST_UNINSTALL, REQUEST_REMOVE_DEVICE_ADMIN));
+ doReturn(false).when(mController).isFallbackPackage(anyString());
+
+ mAppEntry.info = mAppInfo;
+ mAppInfo.packageName = PACKAGE_NAME;
+ mAppInfo.flags = 0;
+ mPackageInfo.packageName = PACKAGE_NAME;
+ mPackageInfo.applicationInfo = mAppInfo;
+
+ mController.mUninstallButton = mUninstallButton;
+ mController.mForceStopButton = mForceStopButton;
+ mController.mPackageInfo = mPackageInfo;
+
+ final ArgumentCaptor<Intent> captor = ArgumentCaptor.forClass(Intent.class);
+ Answer<Void> callable = new Answer<Void>() {
+ @Override
+ public Void answer(InvocationOnMock invocation) throws Exception {
+ mUninstallIntent = captor.getValue();
+ return null;
+ }
+ };
+ doAnswer(callable).when(mFragment).startActivityForResult(captor.capture(), anyInt());
+ }
+
+ @Test
+ public void testRetrieveAppEntry_hasAppEntry_notNull()
+ throws PackageManager.NameNotFoundException {
+ doReturn(mPackageInfo).when(mPackageManger).getPackageInfo(anyString(), anyInt());
+
+ mController.retrieveAppEntry();
+
+ assertThat(mController.mAppEntry).isNotNull();
+ assertThat(mController.mPackageInfo).isNotNull();
+ }
+
+
+ @Test
+ public void testRetrieveAppEntry_noAppEntry_null() throws PackageManager.NameNotFoundException {
+ doReturn(null).when(mState).getEntry(eq(PACKAGE_NAME), anyInt());
+ doReturn(mPackageInfo).when(mPackageManger).getPackageInfo(anyString(), anyInt());
+
+ mController.retrieveAppEntry();
+
+ assertThat(mController.mAppEntry).isNull();
+ assertThat(mController.mPackageInfo).isNull();
+ }
+
+ @Test
+ public void testRetrieveAppEntry_throwException_null() throws
+ PackageManager.NameNotFoundException {
+ doReturn(mAppEntry).when(mState).getEntry(anyString(), anyInt());
+ doThrow(new PackageManager.NameNotFoundException()).when(mPackageManger).getPackageInfo(
+ anyString(), anyInt());
+
+ mController.retrieveAppEntry();
+
+ assertThat(mController.mAppEntry).isNotNull();
+ assertThat(mController.mPackageInfo).isNull();
+ }
+
+ @Test
+ public void testUpdateUninstallButton_isSystemApp_handleAsDisableableButton() {
+ doReturn(false).when(mController).handleDisableable(any());
+ mAppInfo.flags |= ApplicationInfo.FLAG_SYSTEM;
+
+ mController.updateUninstallButton();
+
+ verify(mController).handleDisableable(any());
+ verify(mUninstallButton).setEnabled(false);
+ }
+
+ @Test
+ public void testUpdateUninstallButton_isDeviceAdminApp_setButtonDisable() {
+ doReturn(true).when(mController).handleDisableable(any());
+ mAppInfo.flags |= ApplicationInfo.FLAG_SYSTEM;
+ doReturn(true).when(mDpm).packageHasActiveAdmins(anyString());
+
+ mController.updateUninstallButton();
+
+ verify(mController).handleDisableable(any());
+ verify(mUninstallButton).setEnabled(false);
+ }
+
+ @Test
+ public void testUpdateUninstallButton_isProfileOrDeviceOwner_setButtonDisable() {
+ doReturn(true).when(mDpm).isDeviceOwnerAppOnAnyUser(anyString());
+
+ mController.updateUninstallButton();
+
+ verify(mUninstallButton).setEnabled(false);
+ }
+
+ @Test
+ public void testUpdateUninstallButton_isDeviceProvisioningApp_setButtonDisable() {
+ doReturn(true).when(mDpm).isDeviceOwnerAppOnAnyUser(anyString());
+ when(mSettingsActivity.getResources().getString(anyInt())).thenReturn(PACKAGE_NAME);
+
+ mController.updateUninstallButton();
+
+ verify(mUninstallButton).setEnabled(false);
+ }
+
+ @Test
+ public void testUpdateUninstallButton_isUninstallInQueue_setButtonDisable() {
+ doReturn(true).when(mDpm).isUninstallInQueue(any());
+
+ mController.updateUninstallButton();
+
+ verify(mUninstallButton).setEnabled(false);
+ }
+
+ @Test
+ public void testUpdateUninstallButton_isHomeAppAndBundled_setButtonDisable() {
+ mAppInfo.flags |= ApplicationInfo.FLAG_SYSTEM;
+ mController.mHomePackages.add(PACKAGE_NAME);
+
+ mController.updateUninstallButton();
+
+ verify(mUninstallButton).setEnabled(false);
+ }
+
+ @Test
+ public void testUpdateForceStopButton_HasActiveAdmins_setButtonDisable() {
+ doReturn(true).when(mDpm).packageHasActiveAdmins(anyString());
+
+ mController.updateForceStopButton();
+
+ verify(mController).updateForceStopButtonInner(false);
+ }
+
+ @Test
+ public void testUpdateForceStopButton_AppNotStopped_setButtonEnable() {
+ mController.updateForceStopButton();
+
+ verify(mController).updateForceStopButtonInner(true);
+ }
+
+ @Test
+ public void testUninstallPkg_intentSent() {
+ mController.uninstallPkg(PACKAGE_NAME, ALL_USERS, DISABLE_AFTER_INSTALL);
+
+ verify(mFragment).startActivityForResult(any(), eq(REQUEST_UNINSTALL));
+ assertThat(
+ mUninstallIntent.getBooleanExtra(Intent.EXTRA_UNINSTALL_ALL_USERS, true))
+ .isEqualTo(ALL_USERS);
+ assertThat(mUninstallIntent.getAction()).isEqualTo(Intent.ACTION_UNINSTALL_PACKAGE);
+ assertThat(mController.mDisableAfterUninstall).isEqualTo(DISABLE_AFTER_INSTALL);
+ }
+
+ @Test
+ public void testForceStopPackage_methodInvokedAndUpdated() {
+ final ApplicationsState.AppEntry appEntry = mock(ApplicationsState.AppEntry.class);
+ doReturn(appEntry).when(mState).getEntry(anyString(), anyInt());
+ doNothing().when(mController).updateForceStopButton();
+
+ mController.forceStopPackage(PACKAGE_NAME);
+
+ verify(mAm).forceStopPackage(PACKAGE_NAME);
+ assertThat(mController.mAppEntry).isSameAs(appEntry);
+ verify(mController).updateForceStopButton();
+ }
+
+ @Test
+ public void testHandleDisableable_isHomeApp_notControllable() {
+ mController.mHomePackages.add(PACKAGE_NAME);
+
+ final boolean controllable = mController.handleDisableable(mUninstallButton);
+
+ verify(mUninstallButton).setText(R.string.disable_text);
+ assertThat(controllable).isFalse();
+
+ }
+
+ @Test
+ public void testHandleDisableable_isAppEnabled_controllable() {
+ mAppEntry.info.enabled = true;
+ mAppEntry.info.enabledSetting = PackageManager.COMPONENT_ENABLED_STATE_DEFAULT;
+ doReturn(false).when(mController).isSystemPackage(any(), any(), any());
+
+ final boolean controllable = mController.handleDisableable(mUninstallButton);
+
+ verify(mUninstallButton).setText(R.string.disable_text);
+ assertThat(controllable).isTrue();
+
+ }
+
+ @Test
+ public void testHandleDisableable_isAppDisabled_controllable() {
+ mAppEntry.info.enabled = false;
+ mAppEntry.info.enabledSetting = PackageManager.COMPONENT_ENABLED_STATE_DEFAULT;
+ doReturn(false).when(mController).isSystemPackage(any(), any(), any());
+
+ final boolean controllable = mController.handleDisableable(mUninstallButton);
+
+ verify(mUninstallButton).setText(R.string.enable_text);
+ assertThat(controllable).isTrue();
+ }
+
+ /**
+ * The test fragment which implements
+ * {@link ButtonActionDialogFragment.AppButtonsDialogListener}
+ */
+ private static class TestFragment extends Fragment implements
+ ButtonActionDialogFragment.AppButtonsDialogListener {
+
+ @Override
+ public void handleDialogClick(int type) {
+ // Do nothing
+ }
+ }
+}
diff --git a/tests/robotests/src/com/android/settings/fuelgauge/ButtonActionDialogFragmentTest.java b/tests/robotests/src/com/android/settings/fuelgauge/ButtonActionDialogFragmentTest.java
new file mode 100644
index 0000000..d750382
--- /dev/null
+++ b/tests/robotests/src/com/android/settings/fuelgauge/ButtonActionDialogFragmentTest.java
@@ -0,0 +1,144 @@
+/*
+ * 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.fuelgauge;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.Matchers.anyInt;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+import static org.robolectric.Shadows.shadowOf;
+
+import android.app.AlertDialog;
+import android.app.Fragment;
+import android.content.Context;
+import android.content.DialogInterface;
+
+import com.android.settings.R;
+import com.android.settings.SettingsRobolectricTestRunner;
+import com.android.settings.TestConfig;
+import com.android.settings.testutils.shadow.ShadowEventLogWriter;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.RuntimeEnvironment;
+import org.robolectric.annotation.Config;
+import org.robolectric.shadows.ShadowAlertDialog;
+import org.robolectric.shadows.ShadowDialog;
+import org.robolectric.util.FragmentTestUtil;
+
+@RunWith(SettingsRobolectricTestRunner.class)
+@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION, shadows = {
+ ShadowEventLogWriter.class
+})
+public class ButtonActionDialogFragmentTest {
+ private static final int FORCE_STOP_ID = ButtonActionDialogFragment.DialogType.FORCE_STOP;
+ private static final int DISABLE_ID = ButtonActionDialogFragment.DialogType.DISABLE;
+ private static final int SPECIAL_DISABLE_ID =
+ ButtonActionDialogFragment.DialogType.SPECIAL_DISABLE;
+ @Mock
+ private TestFragment mTargetFragment;
+ private ButtonActionDialogFragment mFragment;
+ private Context mShadowContext;
+
+ @Before
+ public void setUp() {
+ MockitoAnnotations.initMocks(this);
+ mShadowContext = RuntimeEnvironment.application;
+
+ mFragment = spy(ButtonActionDialogFragment.newInstance(FORCE_STOP_ID));
+ doReturn(mShadowContext).when(mFragment).getContext();
+ mFragment.setTargetFragment(mTargetFragment, 0);
+ }
+
+ @Test
+ public void testOnClick_handleToTargetFragment() {
+ mFragment.onClick(null, 0);
+
+ verify(mTargetFragment).handleDialogClick(anyInt());
+ }
+
+ @Test
+ public void testOnCreateDialog_forceStopDialog() {
+ ButtonActionDialogFragment fragment = ButtonActionDialogFragment.newInstance(FORCE_STOP_ID);
+
+ FragmentTestUtil.startFragment(fragment);
+
+ final AlertDialog dialog = (AlertDialog) ShadowDialog.getLatestDialog();
+ ShadowAlertDialog shadowDialog = shadowOf(dialog);
+
+ assertThat(shadowDialog.getMessage()).isEqualTo(
+ mShadowContext.getString(R.string.force_stop_dlg_text));
+ assertThat(shadowDialog.getTitle()).isEqualTo(
+ mShadowContext.getString(R.string.force_stop_dlg_title));
+ assertThat(dialog.getButton(DialogInterface.BUTTON_POSITIVE).getText()).isEqualTo(
+ mShadowContext.getString(R.string.dlg_ok));
+ assertThat(dialog.getButton(DialogInterface.BUTTON_NEGATIVE).getText()).isEqualTo(
+ mShadowContext.getString(R.string.dlg_cancel));
+ }
+
+ @Test
+ public void testOnCreateDialog_disableDialog() {
+ ButtonActionDialogFragment fragment = ButtonActionDialogFragment.newInstance(DISABLE_ID);
+
+ FragmentTestUtil.startFragment(fragment);
+
+ final AlertDialog dialog = (AlertDialog) ShadowDialog.getLatestDialog();
+ ShadowAlertDialog shadowDialog = shadowOf(dialog);
+
+ assertThat(shadowDialog.getMessage()).isEqualTo(
+ mShadowContext.getString(R.string.app_disable_dlg_text));
+ assertThat(dialog.getButton(DialogInterface.BUTTON_POSITIVE).getText()).isEqualTo(
+ mShadowContext.getString(R.string.app_disable_dlg_positive));
+ assertThat(dialog.getButton(DialogInterface.BUTTON_NEGATIVE).getText()).isEqualTo(
+ mShadowContext.getString(R.string.dlg_cancel));
+ }
+
+ @Test
+ public void testOnCreateDialog_specialDisableDialog() {
+ ButtonActionDialogFragment fragment = ButtonActionDialogFragment.newInstance(
+ SPECIAL_DISABLE_ID);
+
+ FragmentTestUtil.startFragment(fragment);
+
+ final AlertDialog dialog = (AlertDialog) ShadowDialog.getLatestDialog();
+ ShadowAlertDialog shadowDialog = shadowOf(dialog);
+
+ assertThat(shadowDialog.getMessage()).isEqualTo(
+ mShadowContext.getString(R.string.app_disable_dlg_text));
+ assertThat(dialog.getButton(DialogInterface.BUTTON_POSITIVE).getText()).isEqualTo(
+ mShadowContext.getString(R.string.app_disable_dlg_positive));
+ assertThat(dialog.getButton(DialogInterface.BUTTON_NEGATIVE).getText()).isEqualTo(
+ mShadowContext.getString(R.string.dlg_cancel));
+ }
+
+ /**
+ * Test fragment that used as the target fragment, it must implement the
+ * {@link com.android.settings.fuelgauge.ButtonActionDialogFragment.AppButtonsDialogListener}
+ */
+ public static class TestFragment extends Fragment implements
+ ButtonActionDialogFragment.AppButtonsDialogListener {
+
+ @Override
+ public void handleDialogClick(int type) {
+ // do nothing
+ }
+ }
+}
diff --git a/tests/robotests/src/com/android/settings/fuelgauge/PowerUsageAdvancedTest.java b/tests/robotests/src/com/android/settings/fuelgauge/PowerUsageAdvancedTest.java
index eb96604..6ac6500 100644
--- a/tests/robotests/src/com/android/settings/fuelgauge/PowerUsageAdvancedTest.java
+++ b/tests/robotests/src/com/android/settings/fuelgauge/PowerUsageAdvancedTest.java
@@ -15,31 +15,40 @@
*/
package com.android.settings.fuelgauge;
+import android.content.Context;
import android.content.pm.PackageManager;
-import android.os.Process;
+
import com.android.internal.os.BatterySipper;
import com.android.internal.os.BatterySipper.DrainType;
import com.android.internal.os.BatteryStatsHelper;
+import com.android.settings.R;
import com.android.settings.SettingsRobolectricTestRunner;
import com.android.settings.TestConfig;
+import com.android.settings.Utils;
import com.android.settings.fuelgauge.PowerUsageAdvanced.PowerUsageData;
import com.android.settings.fuelgauge.PowerUsageAdvanced.PowerUsageData.UsageType;
+
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Answers;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
+import org.robolectric.RuntimeEnvironment;
import org.robolectric.annotation.Config;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
-import java.util.Set;
import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.Matchers.eq;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyInt;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@RunWith(SettingsRobolectricTestRunner.class)
@@ -53,9 +62,13 @@
private static final double TYPE_WIFI_USAGE = 0;
private static final double TOTAL_USAGE = TYPE_APP_USAGE * 2 + TYPE_BLUETOOTH_USAGE
+ TYPE_WIFI_USAGE;
+ private static final double TOTAL_POWER = 500;
private static final double PRECISION = 0.001;
+ private static final String STUB_STRING = "stub_string";
@Mock
- private BatterySipper mBatterySipper;
+ private BatterySipper mNormalBatterySipper;
+ @Mock
+ private BatterySipper mMaxBatterySipper;
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private BatteryStatsHelper mBatteryStatsHelper;
@Mock
@@ -63,11 +76,14 @@
@Mock
private PackageManager mPackageManager;
private PowerUsageAdvanced mPowerUsageAdvanced;
+ private PowerUsageData mPowerUsageData;
+ private Context mShadowContext;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
- mPowerUsageAdvanced = new PowerUsageAdvanced();
+ mShadowContext = RuntimeEnvironment.application;
+ mPowerUsageAdvanced = spy(new PowerUsageAdvanced());
List<BatterySipper> batterySippers = new ArrayList<>();
batterySippers.add(new BatterySipper(DrainType.APP,
@@ -83,16 +99,24 @@
DISCHARGE_AMOUNT);
when(mBatteryStatsHelper.getUsageList()).thenReturn(batterySippers);
when(mBatteryStatsHelper.getTotalPower()).thenReturn(TOTAL_USAGE);
+ when(mPowerUsageAdvanced.getContext()).thenReturn(mShadowContext);
+ doReturn(STUB_STRING).when(mPowerUsageAdvanced).getString(anyInt(), any(), any());
+ doReturn(STUB_STRING).when(mPowerUsageAdvanced).getString(anyInt(), any());
mPowerUsageAdvanced.setPackageManager(mPackageManager);
mPowerUsageAdvanced.setPowerUsageFeatureProvider(mPowerUsageFeatureProvider);
+
+ mPowerUsageData = new PowerUsageData(UsageType.APP);
+ mMaxBatterySipper.totalPowerMah = TYPE_BLUETOOTH_USAGE;
+ mMaxBatterySipper.drainType = DrainType.BLUETOOTH;
+ mNormalBatterySipper.drainType = DrainType.SCREEN;
}
@Test
public void testExtractUsageType_TypeSystem_ReturnSystem() {
- mBatterySipper.drainType = DrainType.APP;
+ mNormalBatterySipper.drainType = DrainType.APP;
when(mPowerUsageFeatureProvider.isTypeSystem(any())).thenReturn(true);
- assertThat(mPowerUsageAdvanced.extractUsageType(mBatterySipper))
+ assertThat(mPowerUsageAdvanced.extractUsageType(mNormalBatterySipper))
.isEqualTo(UsageType.SYSTEM);
}
@@ -105,19 +129,19 @@
assertThat(drainTypes.length).isEqualTo(usageTypes.length);
for (int i = 0, size = drainTypes.length; i < size; i++) {
- mBatterySipper.drainType = drainTypes[i];
- assertThat(mPowerUsageAdvanced.extractUsageType(mBatterySipper))
+ mNormalBatterySipper.drainType = drainTypes[i];
+ assertThat(mPowerUsageAdvanced.extractUsageType(mNormalBatterySipper))
.isEqualTo(usageTypes[i]);
}
}
@Test
public void testExtractUsageType_TypeService_ReturnService() {
- mBatterySipper.drainType = DrainType.APP;
- when(mBatterySipper.getUid()).thenReturn(FAKE_UID_1);
+ mNormalBatterySipper.drainType = DrainType.APP;
+ when(mNormalBatterySipper.getUid()).thenReturn(FAKE_UID_1);
when(mPowerUsageFeatureProvider.isTypeService(any())).thenReturn(true);
- assertThat(mPowerUsageAdvanced.extractUsageType(mBatterySipper))
+ assertThat(mPowerUsageAdvanced.extractUsageType(mNormalBatterySipper))
.isEqualTo(UsageType.SERVICE);
}
@@ -147,6 +171,37 @@
}
@Test
+ public void testUpdateUsageDataSummary_onlyOneApp_showUsageTime() {
+ mPowerUsageData.usageList.add(mNormalBatterySipper);
+ mPowerUsageAdvanced.updateUsageDataSummary(mPowerUsageData, TOTAL_POWER, DISCHARGE_AMOUNT);
+
+ verify(mPowerUsageAdvanced).getString(eq(R.string.battery_used_for), any());
+ }
+
+ @Test
+ public void testUpdateUsageDataSummary_moreThanOneApp_showMaxUsageApp() {
+ mPowerUsageData.usageList.add(mNormalBatterySipper);
+ mPowerUsageData.usageList.add(mMaxBatterySipper);
+ doReturn(mMaxBatterySipper).when(mPowerUsageAdvanced).findBatterySipperWithMaxBatteryUsage(
+ mPowerUsageData.usageList);
+ final double percentage = (TYPE_BLUETOOTH_USAGE / TOTAL_POWER) * DISCHARGE_AMOUNT;
+ mPowerUsageAdvanced.updateUsageDataSummary(mPowerUsageData, TOTAL_POWER, DISCHARGE_AMOUNT);
+
+ verify(mPowerUsageAdvanced).getString(eq(R.string.battery_used_by),
+ eq(Utils.formatPercentage(percentage, true)), any());
+ }
+
+ @Test
+ public void testFindBatterySipperWithMaxBatteryUsage_findCorrectOne() {
+ mPowerUsageData.usageList.add(mNormalBatterySipper);
+ mPowerUsageData.usageList.add(mMaxBatterySipper);
+ BatterySipper sipper = mPowerUsageAdvanced.findBatterySipperWithMaxBatteryUsage(
+ mPowerUsageData.usageList);
+
+ assertThat(sipper).isEqualTo(mMaxBatterySipper);
+ }
+
+ @Test
public void testInit_ContainsAllUsageType() {
final int[] usageTypeSet = mPowerUsageAdvanced.mUsageTypes;
diff --git a/tests/robotests/src/com/android/settings/fuelgauge/PowerUsageFeatureProviderImplTest.java b/tests/robotests/src/com/android/settings/fuelgauge/PowerUsageFeatureProviderImplTest.java
index d467221..f32ea7a 100644
--- a/tests/robotests/src/com/android/settings/fuelgauge/PowerUsageFeatureProviderImplTest.java
+++ b/tests/robotests/src/com/android/settings/fuelgauge/PowerUsageFeatureProviderImplTest.java
@@ -38,8 +38,10 @@
private static final int UID_OTHER = Process.FIRST_APPLICATION_UID + 2;
private static final int UID_CALENDAR = Process.FIRST_APPLICATION_UID + 3;
private static final int UID_MEDIA = Process.FIRST_APPLICATION_UID + 4;
+ private static final int UID_SYSTEMUI = Process.FIRST_APPLICATION_UID + 5;
private static final String[] PACKAGES_CALENDAR = {"com.android.providers.calendar"};
private static final String[] PACKAGES_MEDIA = {"com.android.providers.media"};
+ private static final String[] PACKAGES_SYSTEMUI = {"com.android.systemui"};
@Mock
private Context mContext;
@Mock
@@ -55,12 +57,13 @@
mPowerFeatureProvider = new PowerUsageFeatureProviderImpl(mContext);
when(mPackageManager.getPackagesForUid(UID_CALENDAR)).thenReturn(PACKAGES_CALENDAR);
when(mPackageManager.getPackagesForUid(UID_MEDIA)).thenReturn(PACKAGES_MEDIA);
+ when(mPackageManager.getPackagesForUid(UID_SYSTEMUI)).thenReturn(PACKAGES_SYSTEMUI);
mPowerFeatureProvider.mPackageManager = mPackageManager;
mBatterySipper.uidObj = new FakeUid(UID_OTHER);
}
@Test
- public void testIsTypeSystem_UidRoot_ReturnTrue() {
+ public void testIsTypeSystem_uidRoot_returnTrue() {
mBatterySipper.drainType = BatterySipper.DrainType.APP;
when(mBatterySipper.getUid()).thenReturn(Process.ROOT_UID);
@@ -68,7 +71,7 @@
}
@Test
- public void testIsTypeSystem_UidSystem_ReturnTrue() {
+ public void testIsTypeSystem_uidSystem_returnTrue() {
mBatterySipper.drainType = BatterySipper.DrainType.APP;
when(mBatterySipper.getUid()).thenReturn(Process.SYSTEM_UID);
@@ -76,7 +79,7 @@
}
@Test
- public void testIsTypeSystem_UidMedia_ReturnTrue() {
+ public void testIsTypeSystem_uidMedia_returnTrue() {
mBatterySipper.drainType = BatterySipper.DrainType.APP;
when(mBatterySipper.getUid()).thenReturn(Process.MEDIA_UID);
@@ -84,7 +87,7 @@
}
@Test
- public void testIsTypeSystem_AppCalendar_ReturnTrue() {
+ public void testIsTypeSystem_appCalendar_returnTrue() {
mBatterySipper.drainType = BatterySipper.DrainType.APP;
when(mBatterySipper.getUid()).thenReturn(UID_CALENDAR);
@@ -92,7 +95,7 @@
}
@Test
- public void testIsTypeSystem_AppMedia_ReturnTrue() {
+ public void testIsTypeSystem_appMedia_returnTrue() {
mBatterySipper.drainType = BatterySipper.DrainType.APP;
when(mBatterySipper.getUid()).thenReturn(UID_MEDIA);
@@ -100,7 +103,15 @@
}
@Test
- public void testIsTypeSystem_UidOther_ReturnFalse() {
+ public void testIsTypeSystem_appSystemUi_returnTrue() {
+ mBatterySipper.drainType = BatterySipper.DrainType.APP;
+ when(mBatterySipper.getUid()).thenReturn(UID_SYSTEMUI);
+
+ assertThat(mPowerFeatureProvider.isTypeSystem(mBatterySipper)).isTrue();
+ }
+
+ @Test
+ public void testIsTypeSystem_uidOther_returnFalse() {
mBatterySipper.drainType = BatterySipper.DrainType.APP;
when(mBatterySipper.getUid()).thenReturn(UID_OTHER);
@@ -108,7 +119,7 @@
}
@Test
- public void testIsTypeSystem_UidObjNull_ReturnFalse() {
+ public void testIsTypeSystem_uidObjNull_returnFalse() {
mBatterySipper.drainType = BatterySipper.DrainType.APP;
mBatterySipper.uidObj = null;
diff --git a/tests/robotests/src/com/android/settings/fuelgauge/PowerUsageSummaryTest.java b/tests/robotests/src/com/android/settings/fuelgauge/PowerUsageSummaryTest.java
index a7772bb..a6e0943 100644
--- a/tests/robotests/src/com/android/settings/fuelgauge/PowerUsageSummaryTest.java
+++ b/tests/robotests/src/com/android/settings/fuelgauge/PowerUsageSummaryTest.java
@@ -315,6 +315,12 @@
}
@Test
+ public void testShouldHideSipper_TypeWifi_ReturnTrue() {
+ mNormalBatterySipper.drainType = BatterySipper.DrainType.WIFI;
+ assertThat(mFragment.shouldHideSipper(mNormalBatterySipper)).isTrue();
+ }
+
+ @Test
public void testShouldHideSipper_TypeCell_ReturnTrue() {
mNormalBatterySipper.drainType = BatterySipper.DrainType.CELL;
assertThat(mFragment.shouldHideSipper(mNormalBatterySipper)).isTrue();