From ec8e127ed3a616a7ca223a5bc6d9c4bbc036cd90 Mon Sep 17 00:00:00 2001 From: jackqdyulei Date: Thu, 15 Jun 2017 13:13:09 -0700 Subject: [PATCH] Add anomaly detector for unoptimized bt scanning This cl detects bt anomaly by using BluetoothUnoptimizedScanBackgroundTimer. It will report anomaly if total duration is longer than threshold. Future cl will hook up the threshold to server side. Bug: 36921532 Test: RunSettingsRoboTests Change-Id: I5d6a42b2d2c4fec94387ca59ba8e6a2f3346d047 --- .../settings/fuelgauge/anomaly/Anomaly.java | 7 +- .../fuelgauge/anomaly/AnomalyLoader.java | 16 +- .../fuelgauge/anomaly/AnomalyUtils.java | 4 + .../checker/BluetoothScanAnomalyDetector.java | 116 +++++++++++++ .../checker/WakeLockAnomalyDetector.java | 3 +- .../checker/WakeupAlarmAnomalyDetector.java | 3 +- .../fuelgauge/anomaly/AnomalyLoaderTest.java | 20 ++- .../BluetoothScanAnomalyDetectorTest.java | 154 ++++++++++++++++++ 8 files changed, 313 insertions(+), 10 deletions(-) create mode 100644 src/com/android/settings/fuelgauge/anomaly/checker/BluetoothScanAnomalyDetector.java create mode 100644 tests/robotests/src/com/android/settings/fuelgauge/anomaly/checker/BluetoothScanAnomalyDetectorTest.java diff --git a/src/com/android/settings/fuelgauge/anomaly/Anomaly.java b/src/com/android/settings/fuelgauge/anomaly/Anomaly.java index 37b52fcdb54..746bd7f0492 100644 --- a/src/com/android/settings/fuelgauge/anomaly/Anomaly.java +++ b/src/com/android/settings/fuelgauge/anomaly/Anomaly.java @@ -35,10 +35,12 @@ import java.util.Objects; public class Anomaly implements Parcelable { @Retention(RetentionPolicy.SOURCE) @IntDef({AnomalyType.WAKE_LOCK, - AnomalyType.WAKEUP_ALARM}) + AnomalyType.WAKEUP_ALARM, + AnomalyType.BLUETOOTH_SCAN}) public @interface AnomalyType { int WAKE_LOCK = 0; int WAKEUP_ALARM = 1; + int BLUETOOTH_SCAN = 2; } @Retention(RetentionPolicy.SOURCE) @@ -52,7 +54,8 @@ public class Anomaly implements Parcelable { @AnomalyType public static final int[] ANOMALY_TYPE_LIST = {AnomalyType.WAKE_LOCK, - AnomalyType.WAKEUP_ALARM}; + AnomalyType.WAKEUP_ALARM, + AnomalyType.BLUETOOTH_SCAN}; /** * Type of this this anomaly diff --git a/src/com/android/settings/fuelgauge/anomaly/AnomalyLoader.java b/src/com/android/settings/fuelgauge/anomaly/AnomalyLoader.java index 264c3904d2b..03d4d239131 100644 --- a/src/com/android/settings/fuelgauge/anomaly/AnomalyLoader.java +++ b/src/com/android/settings/fuelgauge/anomaly/AnomalyLoader.java @@ -22,9 +22,9 @@ import android.os.BatteryStats; import android.os.Bundle; import android.os.UserManager; import android.support.annotation.VisibleForTesting; +import android.util.Log; import com.android.internal.os.BatteryStatsHelper; -import com.android.settings.Utils; import com.android.settings.utils.AsyncLoader; import java.util.ArrayList; @@ -35,6 +35,8 @@ import java.util.List; * an empty list if there is no anomaly. */ public class AnomalyLoader extends AsyncLoader> { + private static final String TAG = "AnomalyLoader"; + private static final boolean USE_FAKE_DATA = false; private BatteryStatsHelper mBatteryStatsHelper; private String mPackageName; @@ -108,9 +110,9 @@ public class AnomalyLoader extends AsyncLoader> { List generateFakeData() { final List anomalies = new ArrayList<>(); final Context context = getContext(); + final String packageName = "com.android.settings"; + final CharSequence displayName = "Settings"; try { - final String packageName = "com.android.settings"; - final CharSequence displayName = "Settings"; final int uid = context.getPackageManager().getPackageUid(packageName, 0); anomalies.add(new Anomaly.Builder() @@ -125,8 +127,14 @@ public class AnomalyLoader extends AsyncLoader> { .setPackageName(packageName) .setDisplayName(displayName) .build()); + anomalies.add(new Anomaly.Builder() + .setUid(uid) + .setType(Anomaly.AnomalyType.BLUETOOTH_SCAN) + .setPackageName(packageName) + .setDisplayName(displayName) + .build()); } catch (PackageManager.NameNotFoundException e) { - e.printStackTrace(); + Log.e(TAG, "Cannot find package by name: " + packageName, e); } return anomalies; } diff --git a/src/com/android/settings/fuelgauge/anomaly/AnomalyUtils.java b/src/com/android/settings/fuelgauge/anomaly/AnomalyUtils.java index d2268992eb1..de9f7aad635 100644 --- a/src/com/android/settings/fuelgauge/anomaly/AnomalyUtils.java +++ b/src/com/android/settings/fuelgauge/anomaly/AnomalyUtils.java @@ -23,6 +23,7 @@ import com.android.settings.fuelgauge.anomaly.action.AnomalyAction; import com.android.settings.fuelgauge.anomaly.action.BackgroundCheckAction; import com.android.settings.fuelgauge.anomaly.action.ForceStopAction; import com.android.settings.fuelgauge.anomaly.checker.AnomalyDetector; +import com.android.settings.fuelgauge.anomaly.checker.BluetoothScanAnomalyDetector; import com.android.settings.fuelgauge.anomaly.checker.WakeLockAnomalyDetector; import com.android.settings.fuelgauge.anomaly.checker.WakeupAlarmAnomalyDetector; @@ -56,6 +57,7 @@ public class AnomalyUtils { case Anomaly.AnomalyType.WAKE_LOCK: return new ForceStopAction(mContext); case Anomaly.AnomalyType.WAKEUP_ALARM: + case Anomaly.AnomalyType.BLUETOOTH_SCAN: return new BackgroundCheckAction(mContext); default: return null; @@ -74,6 +76,8 @@ public class AnomalyUtils { return new WakeLockAnomalyDetector(mContext); case Anomaly.AnomalyType.WAKEUP_ALARM: return new WakeupAlarmAnomalyDetector(mContext); + case Anomaly.AnomalyType.BLUETOOTH_SCAN: + return new BluetoothScanAnomalyDetector(mContext); default: return null; } diff --git a/src/com/android/settings/fuelgauge/anomaly/checker/BluetoothScanAnomalyDetector.java b/src/com/android/settings/fuelgauge/anomaly/checker/BluetoothScanAnomalyDetector.java new file mode 100644 index 00000000000..a0aa8b79f7f --- /dev/null +++ b/src/com/android/settings/fuelgauge/anomaly/checker/BluetoothScanAnomalyDetector.java @@ -0,0 +1,116 @@ +/* + * 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.anomaly.checker; + +import android.content.Context; +import android.os.BatteryStats; +import android.os.SystemClock; +import android.support.annotation.VisibleForTesting; +import android.text.format.DateUtils; +import android.util.ArrayMap; + +import com.android.internal.os.BatterySipper; +import com.android.internal.os.BatteryStatsHelper; +import com.android.settings.Utils; +import com.android.settings.fuelgauge.BatteryUtils; +import com.android.settings.fuelgauge.anomaly.Anomaly; +import com.android.settings.fuelgauge.anomaly.AnomalyDetectionPolicy; +import com.android.settings.fuelgauge.anomaly.AnomalyUtils; +import com.android.settings.fuelgauge.anomaly.action.AnomalyAction; + +import java.util.ArrayList; +import java.util.List; + +/** + * Check whether apps have unoptimized bluetooth scanning in the background + */ +public class BluetoothScanAnomalyDetector implements AnomalyDetector { + private static final String TAG = "BluetoothScanAnomalyDetector"; + @VisibleForTesting + BatteryUtils mBatteryUtils; + @VisibleForTesting + AnomalyAction mAnomalyAction; + private long mBluetoothScanningThreshold; + private Context mContext; + + public BluetoothScanAnomalyDetector(Context context) { + this(context, new AnomalyDetectionPolicy(context)); + } + + @VisibleForTesting + BluetoothScanAnomalyDetector(Context context, AnomalyDetectionPolicy policy) { + mContext = context; + mBatteryUtils = BatteryUtils.getInstance(context); + mAnomalyAction = AnomalyUtils.getInstance(context).getAnomalyAction( + Anomaly.AnomalyType.BLUETOOTH_SCAN); + //TODO(b/36921532): hook up it to AnomalyDectionPolicy + mBluetoothScanningThreshold = 30 * DateUtils.MINUTE_IN_MILLIS; + } + + @Override + public List detectAnomalies(BatteryStatsHelper batteryStatsHelper) { + // Detect all apps if targetPackageName is null + return detectAnomalies(batteryStatsHelper, null /* targetPackageName */); + } + + @Override + public List detectAnomalies(BatteryStatsHelper batteryStatsHelper, + String targetPackageName) { + final List batterySippers = batteryStatsHelper.getUsageList(); + final List anomalies = new ArrayList<>(); + final int targetUid = mBatteryUtils.getPackageUid(targetPackageName); + final long elapsedRealtimeMs = SystemClock.elapsedRealtime(); + + for (int i = 0, size = batterySippers.size(); i < size; i++) { + final BatterySipper sipper = batterySippers.get(i); + final BatteryStats.Uid uid = sipper.uidObj; + if (uid == null + || mBatteryUtils.shouldHideSipper(sipper) + || (targetUid != BatteryUtils.UID_NULL && targetUid != uid.getUid())) { + continue; + } + + final long bluetoothTimeMs = getBluetoothUnoptimizedBgTimeMs(uid, elapsedRealtimeMs); + if (bluetoothTimeMs > mBluetoothScanningThreshold) { + final String packageName = mBatteryUtils.getPackageName(uid.getUid()); + final CharSequence displayName = Utils.getApplicationLabel(mContext, + packageName); + + Anomaly anomaly = new Anomaly.Builder() + .setUid(uid.getUid()) + .setType(Anomaly.AnomalyType.BLUETOOTH_SCAN) + .setDisplayName(displayName) + .setPackageName(packageName) + .build(); + + if (mAnomalyAction.isActionActive(anomaly)) { + anomalies.add(anomaly); + } + } + } + + return anomalies; + } + + @VisibleForTesting + public long getBluetoothUnoptimizedBgTimeMs(BatteryStats.Uid uid, long elapsedRealtimeMs) { + BatteryStats.Timer timer = uid.getBluetoothUnoptimizedScanBackgroundTimer(); + + return timer != null ? timer.getTotalDurationMsLocked(elapsedRealtimeMs) : 0; + } + +} diff --git a/src/com/android/settings/fuelgauge/anomaly/checker/WakeLockAnomalyDetector.java b/src/com/android/settings/fuelgauge/anomaly/checker/WakeLockAnomalyDetector.java index 74c43d00f6d..c5d1f561f37 100644 --- a/src/com/android/settings/fuelgauge/anomaly/checker/WakeLockAnomalyDetector.java +++ b/src/com/android/settings/fuelgauge/anomaly/checker/WakeLockAnomalyDetector.java @@ -66,7 +66,8 @@ public class WakeLockAnomalyDetector implements AnomalyDetector { @Override public List detectAnomalies(BatteryStatsHelper batteryStatsHelper) { - return detectAnomalies(batteryStatsHelper, null); + // Detect all apps if targetPackageName is null + return detectAnomalies(batteryStatsHelper, null /* targetPackageName */); } @Override diff --git a/src/com/android/settings/fuelgauge/anomaly/checker/WakeupAlarmAnomalyDetector.java b/src/com/android/settings/fuelgauge/anomaly/checker/WakeupAlarmAnomalyDetector.java index 3502e73d70a..aadfa0c2964 100644 --- a/src/com/android/settings/fuelgauge/anomaly/checker/WakeupAlarmAnomalyDetector.java +++ b/src/com/android/settings/fuelgauge/anomaly/checker/WakeupAlarmAnomalyDetector.java @@ -61,7 +61,8 @@ public class WakeupAlarmAnomalyDetector implements AnomalyDetector { @Override public List detectAnomalies(BatteryStatsHelper batteryStatsHelper) { - return detectAnomalies(batteryStatsHelper, null); + // Detect all apps if targetPackageName is null + return detectAnomalies(batteryStatsHelper, null /* targetPackageName */); } @Override diff --git a/tests/robotests/src/com/android/settings/fuelgauge/anomaly/AnomalyLoaderTest.java b/tests/robotests/src/com/android/settings/fuelgauge/anomaly/AnomalyLoaderTest.java index 8119168f8e5..48749d50860 100644 --- a/tests/robotests/src/com/android/settings/fuelgauge/anomaly/AnomalyLoaderTest.java +++ b/tests/robotests/src/com/android/settings/fuelgauge/anomaly/AnomalyLoaderTest.java @@ -30,6 +30,7 @@ import android.content.pm.PackageManager; import android.os.UserManager; import com.android.internal.os.BatteryStatsHelper; +import com.android.settings.fuelgauge.anomaly.checker.BluetoothScanAnomalyDetector; import com.android.settings.testutils.SettingsRobolectricTestRunner; import com.android.settings.TestConfig; import com.android.settings.fuelgauge.anomaly.checker.WakeLockAnomalyDetector; @@ -62,13 +63,17 @@ public class AnomalyLoaderTest { @Mock private WakeupAlarmAnomalyDetector mWakeupAlarmAnomalyDetector; @Mock + private BluetoothScanAnomalyDetector mBluetoothScanAnomalyDetector; + @Mock private AnomalyDetectionPolicy mAnomalyDetectionPolicy; @Mock private UserManager mUserManager; private Anomaly mWakeLockAnomaly; private Anomaly mWakeupAlarmAnomaly; + private Anomaly mBluetoothScanAnomaly; private List mWakeLockAnomalies; private List mWakeupAlarmAnomalies; + private List mBluetoothScanAnomalies; private AnomalyLoader mAnomalyLoader; @Before @@ -91,6 +96,12 @@ public class AnomalyLoaderTest { doReturn(mWakeupAlarmAnomalies).when(mWakeupAlarmAnomalyDetector).detectAnomalies(any(), any()); + mBluetoothScanAnomalies = new ArrayList<>(); + mBluetoothScanAnomaly = createAnomaly(Anomaly.AnomalyType.BLUETOOTH_SCAN); + mBluetoothScanAnomalies.add(mBluetoothScanAnomaly); + doReturn(mBluetoothScanAnomalies).when(mBluetoothScanAnomalyDetector).detectAnomalies(any(), + any()); + mAnomalyLoader = new AnomalyLoader(mContext, mBatteryStatsHelper, null, mAnomalyDetectionPolicy); mAnomalyLoader.mAnomalyUtils = spy(new AnomalyUtils(mContext)); @@ -102,10 +113,14 @@ public class AnomalyLoaderTest { Anomaly.AnomalyType.WAKE_LOCK); doReturn(mWakeupAlarmAnomalyDetector).when(mAnomalyLoader.mAnomalyUtils).getAnomalyDetector( Anomaly.AnomalyType.WAKEUP_ALARM); + doReturn(mBluetoothScanAnomalyDetector).when( + mAnomalyLoader.mAnomalyUtils).getAnomalyDetector( + Anomaly.AnomalyType.BLUETOOTH_SCAN); List anomalies = mAnomalyLoader.loadInBackground(); - assertThat(anomalies).containsExactly(mWakeLockAnomaly, mWakeupAlarmAnomaly); + assertThat(anomalies).containsExactly(mWakeLockAnomaly, mWakeupAlarmAnomaly, + mBluetoothScanAnomaly); } private Anomaly createAnomaly(@Anomaly.AnomalyType int type) { @@ -121,6 +136,7 @@ public class AnomalyLoaderTest { public void testGenerateFakeData() { List anomalies = mAnomalyLoader.generateFakeData(); - assertThat(anomalies).containsExactly(mWakeLockAnomaly, mWakeupAlarmAnomaly); + assertThat(anomalies).containsExactly(mWakeLockAnomaly, mWakeupAlarmAnomaly, + mBluetoothScanAnomaly); } } diff --git a/tests/robotests/src/com/android/settings/fuelgauge/anomaly/checker/BluetoothScanAnomalyDetectorTest.java b/tests/robotests/src/com/android/settings/fuelgauge/anomaly/checker/BluetoothScanAnomalyDetectorTest.java new file mode 100644 index 00000000000..3db209cd05e --- /dev/null +++ b/tests/robotests/src/com/android/settings/fuelgauge/anomaly/checker/BluetoothScanAnomalyDetectorTest.java @@ -0,0 +1,154 @@ +/* + * 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.anomaly.checker; + +import static com.google.common.truth.Truth.assertThat; + +import static org.mockito.ArgumentMatchers.nullable; +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.anyLong; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.spy; + +import android.content.Context; +import android.content.pm.ApplicationInfo; +import android.os.BatteryStats; +import android.text.format.DateUtils; + +import com.android.internal.os.BatterySipper; +import com.android.internal.os.BatteryStatsHelper; +import com.android.settings.TestConfig; +import com.android.settings.fuelgauge.BatteryUtils; +import com.android.settings.fuelgauge.anomaly.Anomaly; +import com.android.settings.fuelgauge.anomaly.AnomalyDetectionPolicy; +import com.android.settings.fuelgauge.anomaly.action.AnomalyAction; +import com.android.settings.testutils.SettingsRobolectricTestRunner; + +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 java.util.ArrayList; +import java.util.List; + +@RunWith(SettingsRobolectricTestRunner.class) +@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION) +public class BluetoothScanAnomalyDetectorTest { + private static final String TARGET_PACKAGE_NAME = "com.android.app"; + private static final int ANOMALY_UID = 111; + private static final int NORMAL_UID = 222; + private static final int TARGET_UID = 333; + private static final long ANOMALY_BLUETOOTH_SCANNING_TIME = DateUtils.HOUR_IN_MILLIS; + private static final long NORMAL_BLUETOOTH_SCANNING_TIME = DateUtils.MINUTE_IN_MILLIS; + @Mock + private BatteryStatsHelper mBatteryStatsHelper; + @Mock + private BatterySipper mAnomalySipper; + @Mock + private BatterySipper mNormalSipper; + @Mock + private BatterySipper mTargetSipper; + @Mock + private BatteryStats.Uid mAnomalyUid; + @Mock + private BatteryStats.Uid mNormalUid; + @Mock + private BatteryStats.Uid mTargetUid; + @Mock + private BatteryUtils mBatteryUtils; + @Mock + private AnomalyDetectionPolicy mPolicy; + @Mock + private AnomalyAction mAnomalyAction; + + private BluetoothScanAnomalyDetector mBluetoothScanAnomalyDetector; + private Context mContext; + private List mUsageList; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + + mContext = spy(RuntimeEnvironment.application); + + mAnomalySipper.uidObj = mAnomalyUid; + doReturn(ANOMALY_UID).when(mAnomalyUid).getUid(); + mNormalSipper.uidObj = mNormalUid; + doReturn(NORMAL_UID).when(mNormalUid).getUid(); + mTargetSipper.uidObj = mTargetUid; + doReturn(TARGET_UID).when(mTargetUid).getUid(); + + mUsageList = new ArrayList<>(); + mUsageList.add(mAnomalySipper); + mUsageList.add(mNormalSipper); + mUsageList.add(mTargetSipper); + doReturn(mUsageList).when(mBatteryStatsHelper).getUsageList(); + + mBluetoothScanAnomalyDetector = spy(new BluetoothScanAnomalyDetector(mContext, mPolicy)); + mBluetoothScanAnomalyDetector.mBatteryUtils = mBatteryUtils; + mBluetoothScanAnomalyDetector.mAnomalyAction = mAnomalyAction; + doReturn(false).when(mBatteryUtils).shouldHideSipper(any()); + doReturn(true).when(mAnomalyAction).isActionActive(any()); + + doReturn(ANOMALY_BLUETOOTH_SCANNING_TIME).when( + mBluetoothScanAnomalyDetector).getBluetoothUnoptimizedBgTimeMs(eq(mAnomalyUid), + anyLong()); + doReturn(ANOMALY_BLUETOOTH_SCANNING_TIME).when( + mBluetoothScanAnomalyDetector).getBluetoothUnoptimizedBgTimeMs(eq(mTargetUid), + anyLong()); + doReturn(NORMAL_BLUETOOTH_SCANNING_TIME).when( + mBluetoothScanAnomalyDetector).getBluetoothUnoptimizedBgTimeMs(eq(mNormalUid), + anyLong()); + } + + @Test + public void testDetectAnomalies_containsAnomaly_detectIt() { + doReturn(-1).when(mBatteryUtils).getPackageUid(nullable(String.class)); + final Anomaly anomaly = createBluetoothAnomaly(ANOMALY_UID); + final Anomaly targetAnomaly = createBluetoothAnomaly(TARGET_UID); + + List mAnomalies = mBluetoothScanAnomalyDetector.detectAnomalies( + mBatteryStatsHelper); + + assertThat(mAnomalies).containsExactly(anomaly, targetAnomaly); + } + + @Test + public void testDetectAnomalies_detectTargetAnomaly_detectIt() { + doReturn(TARGET_UID).when(mBatteryUtils).getPackageUid(TARGET_PACKAGE_NAME); + final Anomaly targetAnomaly = createBluetoothAnomaly(TARGET_UID); + + List mAnomalies = mBluetoothScanAnomalyDetector.detectAnomalies( + mBatteryStatsHelper, TARGET_PACKAGE_NAME); + + assertThat(mAnomalies).containsExactly(targetAnomaly); + + } + + private Anomaly createBluetoothAnomaly(int uid) { + return new Anomaly.Builder() + .setUid(uid) + .setType(Anomaly.AnomalyType.BLUETOOTH_SCAN) + .build(); + } + +}