import android.content.Intent;
import android.content.IntentFilter;
import android.os.PowerManager;
+import android.support.annotation.IntDef;
import android.support.annotation.VisibleForTesting;
import com.android.settings.Utils;
+import com.android.settings.fuelgauge.batterytip.tips.BatteryTip;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
/**
* Use this broadcastReceiver to listen to the battery change, and it will invoke
* Battery saver(e.g. off->on)
*/
public interface OnBatteryChangedListener {
- void onBatteryChanged();
+ void onBatteryChanged(@BatteryUpdateType int type);
+ }
+
+ @Retention(RetentionPolicy.SOURCE)
+ @IntDef({BatteryUpdateType.MANUAL,
+ BatteryUpdateType.BATTERY_LEVEL,
+ BatteryUpdateType.BATTERY_SAVER,
+ BatteryUpdateType.BATTERY_STATUS})
+ public @interface BatteryUpdateType {
+ int MANUAL = 0;
+ int BATTERY_LEVEL = 1;
+ int BATTERY_SAVER = 2;
+ int BATTERY_STATUS = 3;
}
@VisibleForTesting
final String batteryLevel = Utils.getBatteryPercentage(intent);
final String batteryStatus = Utils.getBatteryStatus(
mContext.getResources(), intent);
- if (forceUpdate || !batteryLevel.equals(mBatteryLevel) || !batteryStatus.equals(
- mBatteryStatus)) {
- mBatteryLevel = batteryLevel;
- mBatteryStatus = batteryStatus;
- mBatteryListener.onBatteryChanged();
+ if (forceUpdate) {
+ mBatteryListener.onBatteryChanged(BatteryUpdateType.MANUAL);
+ } else if(!batteryLevel.equals(mBatteryLevel)) {
+ mBatteryListener.onBatteryChanged(BatteryUpdateType.BATTERY_LEVEL);
+ } else if (!batteryStatus.equals(mBatteryStatus)) {
+ mBatteryListener.onBatteryChanged(BatteryUpdateType.BATTERY_STATUS);
}
+ mBatteryLevel = batteryLevel;
+ mBatteryStatus = batteryStatus;
} else if (PowerManager.ACTION_POWER_SAVE_MODE_CHANGED.equals(intent.getAction())) {
- mBatteryListener.onBatteryChanged();
+ mBatteryListener.onBatteryChanged(BatteryUpdateType.BATTERY_SAVER);
}
}
}
*/
package com.android.settings.fuelgauge;
+import static com.android.settings.fuelgauge.BatteryBroadcastReceiver.BatteryUpdateType;
+
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import com.android.settings.overlay.FeatureFactory;
import com.android.settings.search.BaseSearchIndexProvider;
import com.android.settingslib.core.AbstractPreferenceController;
-import com.android.settingslib.utils.StringUtil;
import java.util.ArrayList;
import java.util.Arrays;
mMetricsFeatureProvider.action(getContext(),
MetricsProto.MetricsEvent.ACTION_SETTINGS_MENU_BATTERY_APPS_TOGGLE,
mShowAllApps);
- restartBatteryStatsLoader();
+ restartBatteryStatsLoader(BatteryUpdateType.MANUAL);
return true;
default:
return super.onOptionsItemSelected(item);
}
@Override
- protected void refreshUi() {
+ protected void refreshUi(@BatteryUpdateType int refreshType) {
final Context context = getContext();
if (context == null) {
return;
*/
package com.android.settings.fuelgauge;
+import static com.android.settings.fuelgauge.BatteryBroadcastReceiver.*;
+
import android.app.Activity;
import android.app.LoaderManager;
import android.content.Context;
import com.android.internal.os.BatteryStatsHelper;
import com.android.settings.dashboard.DashboardFragment;
-import com.android.settingslib.utils.AsyncLoader;
/**
* Common base class for things that need to show the battery usage graph.
*/
-public abstract class PowerUsageBase extends DashboardFragment
- implements LoaderManager.LoaderCallbacks<BatteryStatsHelper> {
+public abstract class PowerUsageBase extends DashboardFragment {
// +1 to allow ordering for PowerUsageSummary.
@VisibleForTesting
static final int MENU_STATS_REFRESH = Menu.FIRST + 1;
private static final String TAG = "PowerUsageBase";
+ private static final String KEY_REFRESH_TYPE = "refresh_type";
protected BatteryStatsHelper mStatsHelper;
protected UserManager mUm;
setHasOptionsMenu(true);
mBatteryBroadcastReceiver = new BatteryBroadcastReceiver(getContext());
- mBatteryBroadcastReceiver.setBatteryChangedListener(() -> {
- restartBatteryStatsLoader();
+ mBatteryBroadcastReceiver.setBatteryChangedListener(type -> {
+ restartBatteryStatsLoader(type);
});
}
mBatteryBroadcastReceiver.unRegister();
}
- protected void restartBatteryStatsLoader() {
- getLoaderManager().restartLoader(0, Bundle.EMPTY, this);
+ protected void restartBatteryStatsLoader(int refreshType) {
+ final Bundle bundle = new Bundle();
+ bundle.putInt(KEY_REFRESH_TYPE, refreshType);
+
+ getLoaderManager().restartLoader(0, bundle, new PowerLoaderCallback());
}
- protected abstract void refreshUi();
+ protected abstract void refreshUi(@BatteryUpdateType int refreshType);
protected void updatePreference(BatteryHistoryPreference historyPref) {
final long startTime = System.currentTimeMillis();
BatteryUtils.logRuntime(TAG, "updatePreference", startTime);
}
- @Override
- public Loader<BatteryStatsHelper> onCreateLoader(int id,
- Bundle args) {
- return new BatteryStatsHelperLoader(getContext());
- }
-
- @Override
- public void onLoadFinished(Loader<BatteryStatsHelper> loader,
- BatteryStatsHelper statsHelper) {
- mStatsHelper = statsHelper;
- refreshUi();
- }
-
- @Override
- public void onLoaderReset(Loader<BatteryStatsHelper> loader) {
-
+ /**
+ * {@link android.app.LoaderManager.LoaderCallbacks} for {@link PowerUsageBase} to load
+ * the {@link BatteryStatsHelper}
+ */
+ public class PowerLoaderCallback implements LoaderManager.LoaderCallbacks<BatteryStatsHelper> {
+ private int mRefreshType;
+
+ @Override
+ public Loader<BatteryStatsHelper> onCreateLoader(int id,
+ Bundle args) {
+ mRefreshType = args.getInt(KEY_REFRESH_TYPE);
+ return new BatteryStatsHelperLoader(getContext());
+ }
+
+ @Override
+ public void onLoadFinished(Loader<BatteryStatsHelper> loader,
+ BatteryStatsHelper statsHelper) {
+ mStatsHelper = statsHelper;
+ refreshUi(mRefreshType);
+ }
+
+ @Override
+ public void onLoaderReset(Loader<BatteryStatsHelper> loader) {
+
+ }
}
}
package com.android.settings.fuelgauge;
+import static com.android.settings.fuelgauge.BatteryBroadcastReceiver.BatteryUpdateType;
+
import android.app.Activity;
import android.app.LoaderManager;
import android.app.LoaderManager.LoaderCallbacks;
} else {
mStatsType = BatteryStats.STATS_SINCE_CHARGED;
}
- refreshUi();
+ refreshUi(BatteryUpdateType.MANUAL);
return true;
case MENU_ADVANCED_BATTERY:
new SubSettingLauncher(getContext())
}
}
- protected void refreshUi() {
+ protected void refreshUi(@BatteryUpdateType int refreshType) {
final Context context = getContext();
if (context == null) {
return;
}
- // Only skip BatteryTipLoader for the first time when device is rotated
- if (mNeedUpdateBatteryTip) {
+ // Skip BatteryTipLoader if device is rotated or only battery level change
+ if (mNeedUpdateBatteryTip
+ && refreshType != BatteryUpdateType.BATTERY_LEVEL) {
restartBatteryTipLoader();
} else {
mNeedUpdateBatteryTip = true;
}
@Override
- protected void restartBatteryStatsLoader() {
- restartBatteryStatsLoader(true /* clearHeader */);
+ protected void restartBatteryStatsLoader(@BatteryUpdateType int refreshType) {
+ super.restartBatteryStatsLoader(refreshType);
+ mBatteryHeaderPreferenceController.quickUpdateHeaderPreference();
}
@Override
mBatteryTipPreferenceController.saveInstanceState(outState);
}
- void restartBatteryStatsLoader(boolean clearHeader) {
- super.restartBatteryStatsLoader();
- if (clearHeader) {
- mBatteryHeaderPreferenceController.quickUpdateHeaderPreference();
- }
- }
-
@Override
public void onBatteryTipHandled(BatteryTip batteryTip) {
restartBatteryTipLoader();
mContext = context;
mLoader = loader;
mBatteryBroadcastReceiver = new BatteryBroadcastReceiver(mContext);
- mBatteryBroadcastReceiver.setBatteryChangedListener(() -> {
+ mBatteryBroadcastReceiver.setBatteryChangedListener(type -> {
BatteryInfo.getBatteryInfo(mContext, new BatteryInfo.Callback() {
@Override
public void onBatteryInfoLoaded(BatteryInfo info) {
*/
package com.android.settings.fuelgauge;
+import static com.android.settings.fuelgauge.BatteryBroadcastReceiver.BatteryUpdateType;
+
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyInt;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.spy;
}
@Test
- public void testOnReceive_batteryDataChanged_dataUpdated() {
+ public void testOnReceive_batteryLevelChanged_dataUpdated() {
mBatteryBroadcastReceiver.onReceive(mContext, mChargingIntent);
assertThat(mBatteryBroadcastReceiver.mBatteryLevel)
.isEqualTo(Utils.getBatteryPercentage(mChargingIntent));
assertThat(mBatteryBroadcastReceiver.mBatteryStatus)
.isEqualTo(Utils.getBatteryStatus(mContext.getResources(), mChargingIntent));
- verify(mBatteryListener).onBatteryChanged();
+ verify(mBatteryListener).onBatteryChanged(BatteryUpdateType.BATTERY_LEVEL);
}
@Test
mBatteryBroadcastReceiver.onReceive(mContext,
new Intent(PowerManager.ACTION_POWER_SAVE_MODE_CHANGED));
- verify(mBatteryListener).onBatteryChanged();
+ verify(mBatteryListener).onBatteryChanged(BatteryUpdateType.BATTERY_SAVER);
}
@Test
assertThat(mBatteryBroadcastReceiver.mBatteryLevel).isEqualTo(batteryLevel);
assertThat(mBatteryBroadcastReceiver.mBatteryStatus).isEqualTo(batteryStatus);
- verify(mBatteryListener, never()).onBatteryChanged();
+ verify(mBatteryListener, never()).onBatteryChanged(anyInt());
}
@Test
assertThat(mBatteryBroadcastReceiver.mBatteryStatus)
.isEqualTo(Utils.getBatteryStatus(mContext.getResources(), mChargingIntent));
// 2 times because register will force update the battery
- verify(mBatteryListener, times(2)).onBatteryChanged();
+ verify(mBatteryListener, times(2)).onBatteryChanged(BatteryUpdateType.MANUAL);
}
}
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.ArgumentMatchers.nullable;
+import static org.mockito.Matchers.anyInt;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
@Test
public void testOptionsMenu_menuAppToggle_metricEventInvoked() {
mFragment.mShowAllApps = false;
- doNothing().when(mFragment).restartBatteryStatsLoader();
+ doNothing().when(mFragment).restartBatteryStatsLoader(anyInt());
mFragment.onOptionsItemSelected(mToggleAppsMenu);
}
@Override
- protected void refreshUi() {
+ protected void refreshUi(int refreshType) {
// Do nothing
}
mFragment.initFeatureProvider();
mBatteryMeterView = new BatteryMeterView(mRealContext);
mBatteryMeterView.mDrawable = new BatteryMeterView.BatteryMeterDrawable(mRealContext, 0);
- doNothing().when(mFragment).restartBatteryStatsLoader();
+ doNothing().when(mFragment).restartBatteryStatsLoader(anyInt());
doReturn(mock(LoaderManager.class)).when(mFragment).getLoaderManager();
doReturn(MENU_ADVANCED_BATTERY).when(mAdvancedPageMenu).getItemId();
}
@Test
- public void restartBatteryStatsLoader_notClearHeader_quickUpdateNotInvoked() {
- mFragment.mBatteryHeaderPreferenceController = mBatteryHeaderPreferenceController;
-
- mFragment.restartBatteryStatsLoader(false /* clearHeader */);
-
- verify(mBatteryHeaderPreferenceController, never()).quickUpdateHeaderPreference();
- }
-
- @Test
public void optionsMenu_advancedPageEnabled() {
when(mFeatureFactory.powerUsageFeatureProvider.isPowerAccountingToggleEnabled())
.thenReturn(true);
when(mFragment.mBatteryTipPreferenceController.needUpdate()).thenReturn(false);
mFragment.updateBatteryTipFlag(new Bundle());
- mFragment.refreshUi();
+ mFragment.refreshUi(BatteryBroadcastReceiver.BatteryUpdateType.MANUAL);
+
+ verify(mFragment, never()).restartBatteryTipLoader();
+ }
+
+ @Test
+ public void refreshUi_batteryLevelChanged_doNotUpdateBatteryTip() {
+ mFragment.mBatteryTipPreferenceController = mock(BatteryTipPreferenceController.class);
+ when(mFragment.mBatteryTipPreferenceController.needUpdate()).thenReturn(true);
+ mFragment.updateBatteryTipFlag(new Bundle());
+
+ mFragment.refreshUi(BatteryBroadcastReceiver.BatteryUpdateType.BATTERY_LEVEL);
verify(mFragment, never()).restartBatteryTipLoader();
}
when(mFragment.mBatteryTipPreferenceController.needUpdate()).thenReturn(true);
mFragment.updateBatteryTipFlag(new Bundle());
- mFragment.refreshUi();
+ mFragment.refreshUi(BatteryBroadcastReceiver.BatteryUpdateType.MANUAL);
verify(mFragment).restartBatteryTipLoader();
}