final Preference preference = batteryTip.buildPreference(mPrefContext);
mBatteryTipMap.put(preference.getKey(), batteryTip);
mPreferenceGroup.addPreference(preference);
- mMetricsFeatureProvider.action(mContext,
- MetricsProto.MetricsEvent.ACTION_BATTERY_TIP_SHOWN,
- batteryTip.getType());
+ batteryTip.log(mContext, mMetricsFeatureProvider);
break;
}
}
import android.support.v7.preference.Preference;
import android.util.SparseIntArray;
+import com.android.settingslib.core.instrumentation.MetricsFeatureProvider;
+
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
*/
public abstract void updateState(BatteryTip tip);
+ /**
+ * Log the battery tip
+ */
+ public abstract void log(Context context, MetricsFeatureProvider metricsFeatureProvider);
+
public Preference buildPreference(Context context) {
Preference preference = new Preference(context);
import android.content.Context;
import android.os.Parcel;
+import com.android.internal.logging.nano.MetricsProto;
import com.android.settings.R;
+import com.android.settingslib.core.instrumentation.MetricsFeatureProvider;
/**
* Tip to show early warning if battery couldn't make to usual charging time
}
@Override
+ public void log(Context context, MetricsFeatureProvider metricsFeatureProvider) {
+ metricsFeatureProvider.action(context, MetricsProto.MetricsEvent.ACTION_EARLY_WARNING_TIP,
+ mState);
+ }
+
+ @Override
public void writeToParcel(Parcel dest, int flags) {
super.writeToParcel(dest, flags);
dest.writeBoolean(mPowerSaveModeOn);
import android.os.Parcelable;
import android.support.annotation.VisibleForTesting;
+import com.android.internal.logging.nano.MetricsProto;
import com.android.settings.R;
import com.android.settings.fuelgauge.batterytip.AppInfo;
+import com.android.settingslib.core.instrumentation.MetricsFeatureProvider;
import com.android.settingslib.utils.StringUtil;
import java.util.List;
mState = tip.mState;
}
+ @Override
+ public void log(Context context, MetricsFeatureProvider metricsFeatureProvider) {
+ metricsFeatureProvider.action(context, MetricsProto.MetricsEvent.ACTION_HIGH_USAGE_TIP,
+ mState);
+ for (int i = 0, size = mHighUsageAppList.size(); i < size; i++) {
+ final AppInfo appInfo = mHighUsageAppList.get(i);
+ metricsFeatureProvider.action(context,
+ MetricsProto.MetricsEvent.ACTION_HIGH_USAGE_TIP_LIST,
+ appInfo.packageName);
+ }
+ }
+
public long getScreenTimeMs() {
return mScreenTimeMs;
}
import android.os.Parcel;
import android.os.Parcelable;
+import com.android.internal.logging.nano.MetricsProto;
import com.android.settings.R;
+import com.android.settingslib.core.instrumentation.MetricsFeatureProvider;
/**
* Tip to show current battery life is short
mState = tip.mState;
}
+ @Override
+ public void log(Context context, MetricsFeatureProvider metricsFeatureProvider) {
+ metricsFeatureProvider.action(context, MetricsProto.MetricsEvent.ACTION_LOW_BATTERY_TIP,
+ mState);
+ }
+
public static final Parcelable.Creator CREATOR = new Parcelable.Creator() {
public BatteryTip createFromParcel(Parcel in) {
return new LowBatteryTip(in);
import android.content.Context;
import android.content.res.Resources;
import android.os.Parcel;
+import android.util.Pair;
import com.android.internal.annotations.VisibleForTesting;
+import com.android.internal.logging.nano.MetricsProto;
import com.android.settings.R;
import com.android.settings.Utils;
import com.android.settings.fuelgauge.batterytip.AppInfo;
+import com.android.settingslib.core.instrumentation.MetricsFeatureProvider;
import java.util.ArrayList;
import java.util.List;
}
}
+ @Override
+ public void log(Context context, MetricsFeatureProvider metricsFeatureProvider) {
+ metricsFeatureProvider.action(context, MetricsProto.MetricsEvent.ACTION_APP_RESTRICTION_TIP,
+ mState);
+ if (mState == StateType.NEW) {
+ for (int i = 0, size = mRestrictAppList.size(); i < size; i++) {
+ final AppInfo appInfo = mRestrictAppList.get(i);
+ for (Integer anomalyType : appInfo.anomalyTypes) {
+ metricsFeatureProvider.action(context,
+ MetricsProto.MetricsEvent.ACTION_APP_RESTRICTION_TIP_LIST,
+ appInfo.packageName,
+ Pair.create(MetricsProto.MetricsEvent.FIELD_CONTEXT, anomalyType));
+ }
+
+ }
+ }
+ }
+
public List<AppInfo> getRestrictAppList() {
return mRestrictAppList;
}
import android.os.Parcel;
import android.provider.Settings;
+import com.android.internal.logging.nano.MetricsProto;
import com.android.settings.R;
+import com.android.settingslib.core.instrumentation.MetricsFeatureProvider;
/**
* Tip to suggest turn on smart battery if it is not on
mState = tip.mState;
}
+ @Override
+ public void log(Context context, MetricsFeatureProvider metricsFeatureProvider) {
+ metricsFeatureProvider.action(context, MetricsProto.MetricsEvent.ACTION_SMART_BATTERY_TIP,
+ mState);
+ }
+
public static final Creator CREATOR = new Creator() {
public BatteryTip createFromParcel(Parcel in) {
return new SmartBatteryTip(in);
import android.os.Parcel;
import android.os.Parcelable;
+import com.android.internal.logging.nano.MetricsProto;
import com.android.settings.R;
+import com.android.settingslib.core.instrumentation.MetricsFeatureProvider;
/**
* Tip to show general summary about battery life
mState = tip.mState;
}
+ @Override
+ public void log(Context context, MetricsFeatureProvider metricsFeatureProvider) {
+ metricsFeatureProvider.action(context, MetricsProto.MetricsEvent.ACTION_SUMMARY_TIP,
+ mState);
+ }
+
public static final Parcelable.Creator CREATOR = new Parcelable.Creator() {
public BatteryTip createFromParcel(Parcel in) {
return new SummaryTip(in);
import com.android.internal.annotations.VisibleForTesting;
import com.android.settings.fuelgauge.batterytip.AppInfo;
+import com.android.settingslib.core.instrumentation.MetricsFeatureProvider;
/**
* Tip to suggest user to remove app restriction. This is the empty tip and it is only used in
}
@Override
+ public void log(Context context, MetricsFeatureProvider metricsFeatureProvider) {
+ // Do nothing
+ }
+
+ @Override
public void writeToParcel(Parcel dest, int flags) {
super.writeToParcel(dest, flags);
dest.writeParcelable(mAppInfo, flags);
package com.android.settings.fuelgauge.batterytip;
import static com.google.common.truth.Truth.assertThat;
+
import static org.mockito.Mockito.spy;
import static org.robolectric.Shadows.shadowOf;
import com.android.settings.fuelgauge.batterytip.tips.HighUsageTip;
import com.android.settings.fuelgauge.batterytip.tips.RestrictAppTip;
import com.android.settings.fuelgauge.batterytip.tips.UnrestrictAppTip;
-import com.android.settings.testutils.FakeFeatureFactory;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
import com.android.settings.testutils.shadow.ShadowUtils;
MockitoAnnotations.initMocks(this);
mContext = spy(RuntimeEnvironment.application);
- FakeFeatureFactory.setupForTest();
List<AppInfo> highUsageTips = new ArrayList<>();
final AppInfo appInfo = new AppInfo.Builder()
ShadowAlertDialog shadowDialog = shadowOf(dialog);
assertThat(shadowDialog.getMessage())
- .isEqualTo(mContext.getString(R.string.battery_tip_dialog_message, "1h"));
+ .isEqualTo(mContext.getString(R.string.battery_tip_dialog_message, "1h"));
}
@Test
assertThat(shadowDialog.getTitle()).isEqualTo("Restrict app?");
assertThat(shadowDialog.getMessage())
- .isEqualTo(mContext.getString(R.string.battery_tip_restrict_app_dialog_message));
+ .isEqualTo(mContext.getString(R.string.battery_tip_restrict_app_dialog_message));
}
@Test
assertThat(shadowDialog.getTitle()).isEqualTo("Restrict 2 apps?");
assertThat(shadowDialog.getMessage())
- .isEqualTo(mContext.getString(R.string.battery_tip_restrict_app_dialog_message));
+ .isEqualTo(mContext.getString(R.string.battery_tip_restrict_app_dialog_message));
assertThat(shadowDialog.getView()).isNotNull();
}
assertThat(shadowDialog.getTitle()).isEqualTo("Remove restriction for app?");
assertThat(shadowDialog.getMessage())
- .isEqualTo(mContext.getString(R.string.battery_tip_unrestrict_app_dialog_message));
+ .isEqualTo(mContext.getString(R.string.battery_tip_unrestrict_app_dialog_message));
}
}
public void testUpdateBatteryTips_logBatteryTip() {
mBatteryTipPreferenceController.updateBatteryTips(mOldBatteryTips);
- verify(mFeatureFactory.metricsFeatureProvider).action(any(Context.class),
- eq(MetricsProto.MetricsEvent.ACTION_BATTERY_TIP_SHOWN),
- eq(BatteryTip.TipType.SUMMARY));
+ verify(mFeatureFactory.metricsFeatureProvider).action(mContext,
+ MetricsProto.MetricsEvent.ACTION_SUMMARY_TIP,
+ BatteryTip.StateType.NEW);
}
@Test
import com.android.settings.R;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
+import com.android.settingslib.core.instrumentation.MetricsFeatureProvider;
import org.junit.Before;
import org.junit.Test;
// do nothing
}
+ @Override
+ public void log(Context context, MetricsFeatureProvider metricsFeatureProvider) {
+ // do nothing
+ }
+
public final Parcelable.Creator CREATOR = new Parcelable.Creator() {
public BatteryTip createFromParcel(Parcel in) {
return new TestBatteryTip(in);
import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.verify;
+
import android.content.Context;
import android.os.Parcel;
+import com.android.internal.logging.nano.MetricsProto;
import com.android.settings.R;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
+import com.android.settingslib.core.instrumentation.MetricsFeatureProvider;
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;
@RunWith(SettingsRobolectricTestRunner.class)
public class EarlyWarningTipTest {
+ @Mock
+ private MetricsFeatureProvider mMetricsFeatureProvider;
private Context mContext;
private EarlyWarningTip mEarlyWarningTip;
@Before
public void setUp() {
+ MockitoAnnotations.initMocks(this);
+
mContext = RuntimeEnvironment.application;
mEarlyWarningTip =
- new EarlyWarningTip(BatteryTip.StateType.NEW, false /* powerSaveModeOn */);
+ new EarlyWarningTip(BatteryTip.StateType.NEW, false /* powerSaveModeOn */);
}
@Test
@Test
public void testInfo_stateNew_displayPowerModeInfo() {
final EarlyWarningTip tip =
- new EarlyWarningTip(BatteryTip.StateType.NEW, false /* powerModeOn */);
+ new EarlyWarningTip(BatteryTip.StateType.NEW, false /* powerModeOn */);
assertThat(tip.getTitle(mContext)).isEqualTo("Turn on Low Battery Mode");
assertThat(tip.getSummary(mContext)).isEqualTo("Extend your battery life");
@Test
public void testInfo_stateHandled_displayPowerModeHandledInfo() {
final EarlyWarningTip tip =
- new EarlyWarningTip(BatteryTip.StateType.HANDLED, false /* powerModeOn */);
+ new EarlyWarningTip(BatteryTip.StateType.HANDLED, false /* powerModeOn */);
assertThat(tip.getTitle(mContext)).isEqualTo("Low Battery Mode is on");
assertThat(tip.getSummary(mContext)).isEqualTo("Some features are limited");
@Test
public void testUpdate_powerModeTurnedOn_typeBecomeHandled() {
final EarlyWarningTip nextTip =
- new EarlyWarningTip(BatteryTip.StateType.INVISIBLE, true /* powerModeOn */);
+ new EarlyWarningTip(BatteryTip.StateType.INVISIBLE, true /* powerModeOn */);
mEarlyWarningTip.updateState(nextTip);
assertThat(earlyWarningTip.getState()).isEqualTo(BatteryTip.StateType.INVISIBLE);
}
+
+ @Test
+ public void testLog() {
+ mEarlyWarningTip.log(mContext, mMetricsFeatureProvider);
+
+ verify(mMetricsFeatureProvider).action(mContext,
+ MetricsProto.MetricsEvent.ACTION_EARLY_WARNING_TIP, BatteryTip.StateType.NEW);
+ }
}
import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.verify;
+
import android.content.Context;
import android.os.Parcel;
import android.text.format.DateUtils;
+import com.android.internal.logging.nano.MetricsProto;
import com.android.settings.fuelgauge.batterytip.AppInfo;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
+import com.android.settingslib.core.instrumentation.MetricsFeatureProvider;
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 java.util.ArrayList;
private static final String PACKAGE_NAME = "com.android.app";
private static final long SCREEN_TIME = 30 * DateUtils.MINUTE_IN_MILLIS;
+ @Mock
+ private MetricsFeatureProvider mMetricsFeatureProvider;
private Context mContext;
private HighUsageTip mBatteryTip;
private List<AppInfo> mUsageAppList;
@Before
public void setUp() {
- mContext = RuntimeEnvironment.application;
+ MockitoAnnotations.initMocks(this);
+ mContext = RuntimeEnvironment.application;
mUsageAppList = new ArrayList<>();
mUsageAppList.add(new AppInfo.Builder()
.setPackageName(PACKAGE_NAME)
"type=2 state=0 { packageName=com.android.app,anomalyTypes={},screenTime=1800000 "
+ "}");
}
+
+ @Test
+ public void testLog_logAppInfo() {
+ mBatteryTip.log(mContext, mMetricsFeatureProvider);
+ verify(mMetricsFeatureProvider).action(mContext,
+ MetricsProto.MetricsEvent.ACTION_HIGH_USAGE_TIP, BatteryTip.StateType.NEW);
+
+ verify(mMetricsFeatureProvider).action(mContext,
+ MetricsProto.MetricsEvent.ACTION_HIGH_USAGE_TIP_LIST,
+ PACKAGE_NAME);
+ }
}
package com.android.settings.fuelgauge.batterytip.tips;
import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyInt;
+import static org.mockito.Matchers.anyString;
import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.never;
import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
import android.content.Context;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager;
import android.os.Parcel;
+import android.util.Pair;
+import com.android.internal.logging.nano.MetricsProto;
import com.android.settings.fuelgauge.batterytip.AppInfo;
import com.android.settings.testutils.SettingsRobolectricTestRunner;
+import com.android.settingslib.core.instrumentation.MetricsFeatureProvider;
import org.junit.Before;
import org.junit.Test;
private ApplicationInfo mApplicationInfo;
@Mock
private PackageManager mPackageManager;
+ @Mock
+ private MetricsFeatureProvider mMetricsFeatureProvider;
@Before
public void setUp() throws Exception {
assertThat(mNewBatteryTip.toString()).isEqualTo(
"type=1 state=0 { packageName=com.android.app,anomalyTypes={0, 1},screenTime=0 }");
}
+
+ @Test
+ public void testLog_stateNew_logAppInfo() {
+ mNewBatteryTip.log(mContext, mMetricsFeatureProvider);
+
+ verify(mMetricsFeatureProvider).action(mContext,
+ MetricsProto.MetricsEvent.ACTION_APP_RESTRICTION_TIP, BatteryTip.StateType.NEW);
+ verify(mMetricsFeatureProvider).action(mContext,
+ MetricsProto.MetricsEvent.ACTION_APP_RESTRICTION_TIP_LIST,
+ PACKAGE_NAME,
+ Pair.create(MetricsProto.MetricsEvent.FIELD_CONTEXT, ANOMALY_WAKEUP));
+ verify(mMetricsFeatureProvider).action(mContext,
+ MetricsProto.MetricsEvent.ACTION_APP_RESTRICTION_TIP_LIST,
+ PACKAGE_NAME,
+ Pair.create(MetricsProto.MetricsEvent.FIELD_CONTEXT, ANOMALY_WAKELOCK));
+ }
+
+ @Test
+ public void testLog_stateHandled_doNotLogAppInfo() {
+ mHandledBatteryTip.log(mContext, mMetricsFeatureProvider);
+
+ verify(mMetricsFeatureProvider).action(mContext,
+ MetricsProto.MetricsEvent.ACTION_APP_RESTRICTION_TIP, BatteryTip.StateType.HANDLED);
+ verify(mMetricsFeatureProvider, never()).action(any(), anyInt(), anyString(), any());
+
+ }
}
--- /dev/null
+/*
+ * Copyright (C) 2018 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.batterytip.tips;
+
+import static org.mockito.Mockito.verify;
+
+import android.content.Context;
+
+import com.android.internal.logging.nano.MetricsProto;
+import com.android.settings.testutils.SettingsRobolectricTestRunner;
+import com.android.settingslib.core.instrumentation.MetricsFeatureProvider;
+
+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;
+
+@RunWith(SettingsRobolectricTestRunner.class)
+public class SmartBatteryTipTest {
+
+ @Mock
+ private MetricsFeatureProvider mMetricsFeatureProvider;
+ private Context mContext;
+ private SmartBatteryTip mSmartBatteryTip;
+
+ @Before
+ public void setUp() {
+ MockitoAnnotations.initMocks(this);
+
+ mContext = RuntimeEnvironment.application;
+ mSmartBatteryTip = new SmartBatteryTip(BatteryTip.StateType.NEW);
+ }
+
+ @Test
+ public void testLog() {
+ mSmartBatteryTip.log(mContext, mMetricsFeatureProvider);
+
+ verify(mMetricsFeatureProvider).action(mContext,
+ MetricsProto.MetricsEvent.ACTION_SMART_BATTERY_TIP, BatteryTip.StateType.NEW);
+ }
+}