PawletOS/app_Settings
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Clean up the legacy anomaly detection mechanism in the Settings

Browse Source 
Clean up the legacy anomaly detection mechanism in the Settings, which is implemented in the 2017-2018. The will be replaced by the new anomaly detection mechanism.

Bug: n/a
Test: make -j64 RunSettingsRoboTests ROBOTEST_FILTER="com.android.settings.fuelgauge"
Change-Id: Id5b5f4987c205c45698b6aa25aeb9604479e79c6
This commit is contained in:
ykhung
2024-01-16 10:09:47 +08:00
committed by YK Hung
parent 5d0121e044
commit 5bf510bf0d
12 changed files with 2 additions and 1326 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
src/com/android/settings/SettingsDumpService.java
View File

@@ -38,7 +38,6 @@ import androidx.annotation.VisibleForTesting;
import com.android.settings.applications.ProcStatsData;
import com.android.settings.datausage.lib.DataUsageLib;
import com.android.settings.fuelgauge.batterytip.AnomalyConfigJobService;
import com.android.settings.network.MobileNetworkRepository;
import com.android.settingslib.net.DataUsageController;
@@ -99,7 +98,6 @@ public class SettingsDumpService extends Service {
dump.put(KEY_DATAUSAGE, dumpDataUsage());
dump.put(KEY_MEMORY, dumpMemory());
dump.put(KEY_DEFAULT_BROWSER_APP, dumpDefaultBrowser());
dump.put(KEY_ANOMALY_DETECTION, dumpAnomalyDetection());
} catch (Exception e) {
Log.w(TAG, "exception in dump: ", e);
}
@@ -197,20 +195,6 @@ public class SettingsDumpService extends Service {
}
}
@VisibleForTesting
JSONObject dumpAnomalyDetection() throws JSONException {
final JSONObject obj = new JSONObject();
final SharedPreferences sharedPreferences = getSharedPreferences(
AnomalyConfigJobService.PREF_DB,
Context.MODE_PRIVATE);
final int currentVersion = sharedPreferences.getInt(
AnomalyConfigJobService.KEY_ANOMALY_CONFIG_VERSION,
0 /* defValue */);
obj.put("anomaly_config_version", String.valueOf(currentVersion));
return obj;
}
private void dumpMobileNetworkSettings(IndentingPrintWriter writer) {
MobileNetworkRepository.getInstance(this).dump(writer);
}

80
src/com/android/settings/fuelgauge/batterytip/AnomalyCleanupJobService.java
View File

@@ -1,80 +0,0 @@
/*
* 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;
import android.app.job.JobInfo;
import android.app.job.JobParameters;
import android.app.job.JobScheduler;
import android.app.job.JobService;
import android.content.ComponentName;
import android.content.Context;
import android.util.Log;
import androidx.annotation.VisibleForTesting;
import com.android.settings.R;
import com.android.settingslib.utils.ThreadUtils;
import java.util.concurrent.TimeUnit;
/** A JobService to clean up obsolete data in anomaly database */
public class AnomalyCleanupJobService extends JobService {
private static final String TAG = "AnomalyCleanUpJobService";
@VisibleForTesting static final long CLEAN_UP_FREQUENCY_MS = TimeUnit.DAYS.toMillis(1);
public static void scheduleCleanUp(Context context) {
final JobScheduler jobScheduler = context.getSystemService(JobScheduler.class);
final ComponentName component = new ComponentName(context, AnomalyCleanupJobService.class);
final JobInfo.Builder jobBuilder =
new JobInfo.Builder(R.integer.job_anomaly_clean_up, component)
.setPeriodic(CLEAN_UP_FREQUENCY_MS)
.setRequiresDeviceIdle(true)
.setRequiresCharging(true)
.setPersisted(true);
final JobInfo pending = jobScheduler.getPendingJob(R.integer.job_anomaly_clean_up);
// Don't schedule it if it already exists, to make sure it runs periodically even after
// reboot
if (pending == null
&& jobScheduler.schedule(jobBuilder.build()) != JobScheduler.RESULT_SUCCESS) {
Log.i(TAG, "Anomaly clean up job service schedule failed.");
}
}
@Override
public boolean onStartJob(JobParameters params) {
final BatteryDatabaseManager batteryDatabaseManager =
BatteryDatabaseManager.getInstance(this);
final BatteryTipPolicy policy = new BatteryTipPolicy(this);
ThreadUtils.postOnBackgroundThread(
() -> {
batteryDatabaseManager.deleteAllAnomaliesBeforeTimeStamp(
System.currentTimeMillis()
- TimeUnit.DAYS.toMillis(policy.dataHistoryRetainDay));
jobFinished(params, false /* wantsReschedule */);
});
return true;
}
@Override
public boolean onStopJob(JobParameters jobParameters) {
return false;
}
}

139
src/com/android/settings/fuelgauge/batterytip/AnomalyConfigJobService.java
View File

@@ -1,139 +0,0 @@
/*
* 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;
import android.app.StatsManager;
import android.app.job.JobInfo;
import android.app.job.JobParameters;
import android.app.job.JobScheduler;
import android.app.job.JobService;
import android.content.ComponentName;
import android.content.Context;
import android.content.SharedPreferences;
import android.provider.Settings;
import android.text.TextUtils;
import android.util.Base64;
import android.util.Log;
import androidx.annotation.VisibleForTesting;
import com.android.settings.R;
import com.android.settingslib.utils.ThreadUtils;
import java.util.concurrent.TimeUnit;
/** A JobService check whether to update the anomaly config periodically */
public class AnomalyConfigJobService extends JobService {
private static final String TAG = "AnomalyConfigJobService";
public static final String PREF_DB = "anomaly_pref";
public static final String KEY_ANOMALY_CONFIG_VERSION = "anomaly_config_version";
private static final int DEFAULT_VERSION = 0;
@VisibleForTesting static final long CONFIG_UPDATE_FREQUENCY_MS = TimeUnit.DAYS.toMillis(1);
public static void scheduleConfigUpdate(Context context) {
final JobScheduler jobScheduler = context.getSystemService(JobScheduler.class);
final ComponentName component = new ComponentName(context, AnomalyConfigJobService.class);
final JobInfo.Builder jobBuilder =
new JobInfo.Builder(R.integer.job_anomaly_config_update, component)
.setPeriodic(CONFIG_UPDATE_FREQUENCY_MS)
.setRequiresDeviceIdle(true)
.setRequiresCharging(true)
.setPersisted(true);
final JobInfo pending = jobScheduler.getPendingJob(R.integer.job_anomaly_config_update);
// Don't schedule it if it already exists, to make sure it runs periodically even after
// reboot
if (pending == null
&& jobScheduler.schedule(jobBuilder.build()) != JobScheduler.RESULT_SUCCESS) {
Log.i(TAG, "Anomaly config update job service schedule failed.");
}
}
@Override
public boolean onStartJob(JobParameters params) {
ThreadUtils.postOnBackgroundThread(
() -> {
final StatsManager statsManager = getSystemService(StatsManager.class);
checkAnomalyConfig(statsManager);
try {
BatteryTipUtils.uploadAnomalyPendingIntent(this, statsManager);
} catch (StatsManager.StatsUnavailableException e) {
Log.w(TAG, "Failed to uploadAnomalyPendingIntent.", e);
}
jobFinished(params, false /* wantsReschedule */);
});
return true;
}
@Override
public boolean onStopJob(JobParameters jobParameters) {
return false;
}
@VisibleForTesting
synchronized void checkAnomalyConfig(StatsManager statsManager) {
final SharedPreferences sharedPreferences =
getSharedPreferences(PREF_DB, Context.MODE_PRIVATE);
final int currentVersion =
sharedPreferences.getInt(KEY_ANOMALY_CONFIG_VERSION, DEFAULT_VERSION);
final int newVersion =
Settings.Global.getInt(
getContentResolver(),
Settings.Global.ANOMALY_CONFIG_VERSION,
DEFAULT_VERSION);
final String rawConfig =
Settings.Global.getString(getContentResolver(), Settings.Global.ANOMALY_CONFIG);
Log.i(TAG, "CurrentVersion: " + currentVersion + " new version: " + newVersion);
if (newVersion > currentVersion) {
try {
statsManager.removeConfig(StatsManagerConfig.ANOMALY_CONFIG_KEY);
} catch (StatsManager.StatsUnavailableException e) {
Log.i(
TAG,
"When updating anomaly config, failed to first remove the old config "
+ StatsManagerConfig.ANOMALY_CONFIG_KEY,
e);
}
if (!TextUtils.isEmpty(rawConfig)) {
try {
final byte[] config = Base64.decode(rawConfig, Base64.DEFAULT);
statsManager.addConfig(StatsManagerConfig.ANOMALY_CONFIG_KEY, config);
Log.i(
TAG,
"Upload the anomaly config. configKey: "
+ StatsManagerConfig.ANOMALY_CONFIG_KEY);
SharedPreferences.Editor editor = sharedPreferences.edit();
editor.putInt(KEY_ANOMALY_CONFIG_VERSION, newVersion);
editor.commit();
} catch (IllegalArgumentException e) {
Log.e(TAG, "Anomaly raw config is in wrong format", e);
} catch (StatsManager.StatsUnavailableException e) {
Log.i(
TAG,
"Upload of anomaly config failed for configKey "
+ StatsManagerConfig.ANOMALY_CONFIG_KEY,
e);
}
}
}
}
}

52
src/com/android/settings/fuelgauge/batterytip/AnomalyConfigReceiver.java
View File

@@ -1,52 +0,0 @@
/*
* 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;
import android.app.StatsManager;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.util.Log;
/**
* Receive broadcast when {@link StatsManager} restart, then check the anomaly config and prepare
* info for {@link StatsManager}
*/
public class AnomalyConfigReceiver extends BroadcastReceiver {
private static final String TAG = "AnomalyConfigReceiver";
@Override
public void onReceive(Context context, Intent intent) {
if (StatsManager.ACTION_STATSD_STARTED.equals(intent.getAction())
|| Intent.ACTION_BOOT_COMPLETED.equals(intent.getAction())) {
final StatsManager statsManager = context.getSystemService(StatsManager.class);
// Check whether to update the config
AnomalyConfigJobService.scheduleConfigUpdate(context);
try {
BatteryTipUtils.uploadAnomalyPendingIntent(context, statsManager);
} catch (StatsManager.StatsUnavailableException e) {
Log.w(TAG, "Failed to uploadAnomalyPendingIntent.", e);
}
if (Intent.ACTION_BOOT_COMPLETED.equals(intent.getAction())) {
AnomalyCleanupJobService.scheduleCleanUp(context);
}
}
}
}

267
src/com/android/settings/fuelgauge/batterytip/AnomalyDetectionJobService.java
View File

@@ -1,267 +0,0 @@
/*
* 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;
import static android.os.StatsDimensionsValue.INT_VALUE_TYPE;
import static android.os.StatsDimensionsValue.TUPLE_VALUE_TYPE;
import android.app.AppOpsManager;
import android.app.StatsManager;
import android.app.job.JobInfo;
import android.app.job.JobParameters;
import android.app.job.JobScheduler;
import android.app.job.JobService;
import android.app.job.JobWorkItem;
import android.app.settings.SettingsEnums;
import android.content.ComponentName;
import android.content.ContentResolver;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.os.StatsDimensionsValue;
import android.os.UserManager;
import android.provider.Settings;
import android.util.Log;
import androidx.annotation.GuardedBy;
import androidx.annotation.VisibleForTesting;
import com.android.internal.util.ArrayUtils;
import com.android.settings.R;
import com.android.settings.fuelgauge.BatteryUtils;
import com.android.settings.fuelgauge.PowerUsageFeatureProvider;
import com.android.settings.overlay.FeatureFactory;
import com.android.settingslib.core.instrumentation.MetricsFeatureProvider;
import com.android.settingslib.fuelgauge.PowerAllowlistBackend;
import com.android.settingslib.utils.ThreadUtils;
import java.time.Duration;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;
/** A JobService to store anomaly data to anomaly database */
public class AnomalyDetectionJobService extends JobService {
private static final String TAG = "AnomalyDetectionService";
private static final int ON = 1;
@VisibleForTesting static final int UID_NULL = -1;
@VisibleForTesting static final int STATSD_UID_FILED = 1;
@VisibleForTesting static final long MAX_DELAY_MS = Duration.ofDays(1).toMillis();
private final Object mLock = new Object();
@GuardedBy("mLock")
@VisibleForTesting
boolean mIsJobCanceled = false;
public static void scheduleAnomalyDetection(Context context, Intent intent) {
final JobScheduler jobScheduler = context.getSystemService(JobScheduler.class);
final ComponentName component =
new ComponentName(context, AnomalyDetectionJobService.class);
final JobInfo.Builder jobBuilder =
new JobInfo.Builder(R.integer.job_anomaly_detection, component)
.setOverrideDeadline(MAX_DELAY_MS);
if (jobScheduler.enqueue(jobBuilder.build(), new JobWorkItem(intent))
!= JobScheduler.RESULT_SUCCESS) {
Log.i(TAG, "Anomaly detection job service enqueue failed.");
}
}
@Override
public boolean onStartJob(JobParameters params) {
synchronized (mLock) {
mIsJobCanceled = false;
}
ThreadUtils.postOnBackgroundThread(
() -> {
final Context context = AnomalyDetectionJobService.this;
final BatteryDatabaseManager batteryDatabaseManager =
BatteryDatabaseManager.getInstance(this);
final BatteryTipPolicy policy = new BatteryTipPolicy(this);
final BatteryUtils batteryUtils = BatteryUtils.getInstance(this);
final ContentResolver contentResolver = getContentResolver();
final UserManager userManager = getSystemService(UserManager.class);
final PowerAllowlistBackend powerAllowlistBackend =
PowerAllowlistBackend.getInstance(context);
final PowerUsageFeatureProvider powerUsageFeatureProvider =
FeatureFactory.getFeatureFactory().getPowerUsageFeatureProvider();
final MetricsFeatureProvider metricsFeatureProvider =
FeatureFactory.getFeatureFactory().getMetricsFeatureProvider();
for (JobWorkItem item = dequeueWork(params);
item != null;
item = dequeueWork(params)) {
saveAnomalyToDatabase(
context,
userManager,
batteryDatabaseManager,
batteryUtils,
policy,
powerAllowlistBackend,
contentResolver,
powerUsageFeatureProvider,
metricsFeatureProvider,
item.getIntent().getExtras());
completeWork(params, item);
}
});
return true;
}
@Override
public boolean onStopJob(JobParameters jobParameters) {
synchronized (mLock) {
mIsJobCanceled = true;
}
return true; // Need to reschedule
}
@VisibleForTesting
void saveAnomalyToDatabase(
Context context,
UserManager userManager,
BatteryDatabaseManager databaseManager,
BatteryUtils batteryUtils,
BatteryTipPolicy policy,
PowerAllowlistBackend powerAllowlistBackend,
ContentResolver contentResolver,
PowerUsageFeatureProvider powerUsageFeatureProvider,
MetricsFeatureProvider metricsFeatureProvider,
Bundle bundle) {
// The Example of intentDimsValue is: 35:{1:{1:{1:10013|}|}|}
final StatsDimensionsValue intentDimsValue =
bundle.getParcelable(StatsManager.EXTRA_STATS_DIMENSIONS_VALUE);
final long timeMs =
bundle.getLong(
AnomalyDetectionReceiver.KEY_ANOMALY_TIMESTAMP, System.currentTimeMillis());
final ArrayList<String> cookies =
bundle.getStringArrayList(StatsManager.EXTRA_STATS_BROADCAST_SUBSCRIBER_COOKIES);
final AnomalyInfo anomalyInfo =
new AnomalyInfo(!ArrayUtils.isEmpty(cookies) ? cookies.get(0) : "");
Log.i(TAG, "Extra stats value: " + intentDimsValue.toString());
try {
final int uid = extractUidFromStatsDimensionsValue(intentDimsValue);
final boolean autoFeatureOn =
powerUsageFeatureProvider.isSmartBatterySupported()
? Settings.Global.getInt(
contentResolver,
Settings.Global.ADAPTIVE_BATTERY_MANAGEMENT_ENABLED,
ON)
== ON
: Settings.Global.getInt(
contentResolver,
Settings.Global.APP_AUTO_RESTRICTION_ENABLED,
ON)
== ON;
final String packageName = batteryUtils.getPackageName(uid);
final long versionCode = batteryUtils.getAppLongVersionCode(packageName);
final String versionedPackage = packageName + "/" + versionCode;
if (batteryUtils.shouldHideAnomaly(powerAllowlistBackend, uid, anomalyInfo)) {
metricsFeatureProvider.action(
SettingsEnums.PAGE_UNKNOWN,
SettingsEnums.ACTION_ANOMALY_IGNORED,
SettingsEnums.PAGE_UNKNOWN,
versionedPackage,
anomalyInfo.anomalyType);
} else {
if (autoFeatureOn && anomalyInfo.autoRestriction) {
// Auto restrict this app
batteryUtils.setForceAppStandby(uid, packageName, AppOpsManager.MODE_IGNORED);
databaseManager.insertAnomaly(
uid,
packageName,
anomalyInfo.anomalyType,
AnomalyDatabaseHelper.State.AUTO_HANDLED,
timeMs);
} else {
databaseManager.insertAnomaly(
uid,
packageName,
anomalyInfo.anomalyType,
AnomalyDatabaseHelper.State.NEW,
timeMs);
}
metricsFeatureProvider.action(
SettingsEnums.PAGE_UNKNOWN,
SettingsEnums.ACTION_ANOMALY_TRIGGERED,
SettingsEnums.PAGE_UNKNOWN,
versionedPackage,
anomalyInfo.anomalyType);
}
} catch (NullPointerException | IndexOutOfBoundsException e) {
Log.e(TAG, "Parse stats dimensions value error.", e);
}
}
/**
* Extract the uid from {@link StatsDimensionsValue} <br>
* <br>
* The uid dimension has the format: {1:int} inside the tuple list. Here are some examples: <br>
* 1.Excessive bg anomaly: 27:{1:10089|} <br>
* 2.Wakeup alarm anomaly: 35:{1:{1:{1:10013|}|}|} <br>
* 3.Bluetooth anomaly: 3:{1:{1:{1:10140|}|}|}
*/
@VisibleForTesting
int extractUidFromStatsDimensionsValue(StatsDimensionsValue statsDimensionsValue) {
if (statsDimensionsValue == null) {
return UID_NULL;
}
if (statsDimensionsValue.isValueType(INT_VALUE_TYPE)
&& statsDimensionsValue.getField() == STATSD_UID_FILED) {
// Find out the real uid
return statsDimensionsValue.getIntValue();
}
if (statsDimensionsValue.isValueType(TUPLE_VALUE_TYPE)) {
final List<StatsDimensionsValue> values = statsDimensionsValue.getTupleValueList();
for (int i = 0, size = values.size(); i < size; i++) {
int uid = extractUidFromStatsDimensionsValue(values.get(i));
if (uid != UID_NULL) {
return uid;
}
}
}
return UID_NULL;
}
@VisibleForTesting
JobWorkItem dequeueWork(JobParameters parameters) {
synchronized (mLock) {
if (mIsJobCanceled) {
return null;
}
return parameters.dequeueWork();
}
}
@VisibleForTesting
void completeWork(JobParameters parameters, JobWorkItem item) {
synchronized (mLock) {
if (mIsJobCanceled) {
return;
}
parameters.completeWork(item);
}
}
}

55
src/com/android/settings/fuelgauge/batterytip/AnomalyDetectionReceiver.java
View File

@@ -1,55 +0,0 @@
/*
* 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;
import android.app.StatsManager;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.util.Log;
/** Receive the anomaly info from {@link StatsManager} */
public class AnomalyDetectionReceiver extends BroadcastReceiver {
private static final String TAG = "SettingsAnomalyReceiver";
public static final String KEY_ANOMALY_TIMESTAMP = "key_anomaly_timestamp";
@Override
public void onReceive(Context context, Intent intent) {
final long configUid = intent.getLongExtra(StatsManager.EXTRA_STATS_CONFIG_UID, -1);
final long configKey = intent.getLongExtra(StatsManager.EXTRA_STATS_CONFIG_KEY, -1);
final long subscriptionId =
intent.getLongExtra(StatsManager.EXTRA_STATS_SUBSCRIPTION_ID, -1);
Log.i(
TAG,
"Anomaly intent received. configUid = "
+ configUid
+ " configKey = "
+ configKey
+ " subscriptionId = "
+ subscriptionId);
final Bundle bundle = intent.getExtras();
if (bundle == null) {
return;
}
bundle.putLong(KEY_ANOMALY_TIMESTAMP, System.currentTimeMillis());
AnomalyDetectionJobService.scheduleAnomalyDetection(context, intent);
}
}

34
src/com/android/settings/fuelgauge/batterytip/BatteryTipUtils.java
View File

@@ -17,8 +17,6 @@
package com.android.settings.fuelgauge.batterytip;
import android.app.AppOpsManager;
import android.app.PendingIntent;
import android.app.StatsManager;
import android.content.Context;
import android.content.Intent;
import android.os.UserHandle;
@@ -111,36 +109,8 @@ public class BatteryTipUtils {
}
}
/**
* Upload the {@link PendingIntent} to {@link StatsManager} for anomaly detection
*
* @throws StatsManager.StatsUnavailableException if failed to communicate with stats service
*/
public static void uploadAnomalyPendingIntent(Context context, StatsManager statsManager)
throws StatsManager.StatsUnavailableException {
final Intent extraIntent = new Intent(context, AnomalyDetectionReceiver.class);
final PendingIntent pendingIntent =
PendingIntent.getBroadcast(
context,
REQUEST_CODE,
extraIntent,
PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_MUTABLE);
statsManager.setBroadcastSubscriber(
pendingIntent,
StatsManagerConfig.ANOMALY_CONFIG_KEY,
StatsManagerConfig.SUBSCRIBER_ID);
}
/** Detect and return anomaly apps after {@code timeAfterMs} */
/** Detect and return anomaly apps after {@code timeAfterMs} */
public static List<AppInfo> detectAnomalies(Context context, long timeAfterMs) {
final List<AppInfo> highUsageApps =
BatteryDatabaseManager.getInstance(context)
.queryAllAnomalies(timeAfterMs, AnomalyDatabaseHelper.State.NEW);
// Remove it if it doesn't have label or been restricted
highUsageApps.removeIf(
AppLabelPredicate.getInstance(context)
.or(AppRestrictionPredicate.getInstance(context)));
return highUsageApps;
return new ArrayList<>();
}
}