Add auto restriction for excessive background

If it is excessive bg anomaly and auto restriction is on, then
restrict the anomaly in receiver and store it in database.

Also in this cl we move the anomaly logic to a JobService, so all
works are done in a background thread and won't interfere the main
thread.

Bug: 72385333
Test: RunSettingsRoboTests &&
Will add auto restriction test once robo framework is updated(b/73172999)
Change-Id: Id0ec5fb449ce26bf19a292bcbe63838d621cfd8e

src/com/android/settings/fuelgauge/batterytip/AnomalyDetectionJobService.java

@@ -0,0 +1,169 @@
+/*
+ * 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.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.SystemPropertiesProto;
+import android.provider.Settings;
+import android.support.annotation.VisibleForTesting;
+import android.util.Log;
+
+import com.android.settings.R;
+import com.android.settings.fuelgauge.BatteryUtils;
+import com.android.settingslib.utils.ThreadUtils;
+
+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 UID_NULL = 0;
+    private static final int STATSD_UID_FILED = 1;
+    private static final int ON = 1;
+
+    @VisibleForTesting
+    static final long MAX_DELAY_MS = TimeUnit.MINUTES.toMillis(30);
+
+    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.id.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) {
+        ThreadUtils.postOnBackgroundThread(() -> {
+            final BatteryDatabaseManager batteryDatabaseManager =
+                    BatteryDatabaseManager.getInstance(this);
+            final BatteryTipPolicy policy = new BatteryTipPolicy(this);
+            final BatteryUtils batteryUtils = BatteryUtils.getInstance(this);
+            final ContentResolver contentResolver = getContentResolver();
+
+            for (JobWorkItem item = params.dequeueWork(); item != null;
+                    item = params.dequeueWork()) {
+                saveAnomalyToDatabase(batteryDatabaseManager, batteryUtils, policy, contentResolver,
+                        item.getIntent().getExtras());
+            }
+            jobFinished(params, false /* wantsReschedule */);
+        });
+
+        return true;
+    }
+
+    @Override
+    public boolean onStopJob(JobParameters jobParameters) {
+        return false;
+    }
+
+    @VisibleForTesting
+    void saveAnomalyToDatabase(BatteryDatabaseManager databaseManager,
+            BatteryUtils batteryUtils, BatteryTipPolicy policy, ContentResolver contentResolver,
+            Bundle bundle) {
+        // The Example of intentDimsValue is: 35:{1:{1:{1:10013|}|}|}
+        final StatsDimensionsValue intentDimsValue =
+                bundle.getParcelable(StatsManager.EXTRA_STATS_DIMENSIONS_VALUE);
+        final long subscriptionId = bundle.getLong(StatsManager.EXTRA_STATS_SUBSCRIPTION_ID,
+                -1);
+        final long timeMs = bundle.getLong(AnomalyDetectionReceiver.KEY_ANOMALY_TIMESTAMP,
+                System.currentTimeMillis());
+        Log.i(TAG, "Extra stats value: " + intentDimsValue.toString());
+
+        try {
+            final int uid = extractUidFromStatsDimensionsValue(intentDimsValue);
+            final int anomalyType = StatsManagerConfig.getAnomalyTypeFromSubscriptionId(
+                    subscriptionId);
+            final boolean smartBatteryOn = Settings.Global.getInt(contentResolver,
+                    Settings.Global.APP_STANDBY_ENABLED, ON) == ON;
+            final String packageName = batteryUtils.getPackageName(uid);
+
+            if (anomalyType == StatsManagerConfig.AnomalyType.EXCESSIVE_BG) {
+                // TODO(b/72385333): check battery percentage draining in batterystats
+                if (batteryUtils.isLegacyApp(packageName)) {
+                    Log.e(TAG, "Excessive detected uid=" + uid);
+                    batteryUtils.setForceAppStandby(uid, packageName,
+                            AppOpsManager.MODE_IGNORED);
+                    databaseManager.insertAnomaly(packageName, anomalyType,
+                            smartBatteryOn
+                                    ? AnomalyDatabaseHelper.State.AUTO_HANDLED
+                                    : AnomalyDatabaseHelper.State.NEW,
+                            timeMs);
+                }
+            } else {
+                databaseManager.insertAnomaly(packageName, anomalyType,
+                        AnomalyDatabaseHelper.State.NEW, timeMs);
+            }
+        } catch (NullPointerException | IndexOutOfBoundsException e) {
+            Log.e(TAG, "Parse stats dimensions value error.", e);
+        }
+    }
+
+    /**
+     * Extract the uid from {@link StatsDimensionsValue}
+     *
+     * The uid dimension has the format: 1:<int> inside the tuple list. Here are some examples:
+     * 1. Excessive bg anomaly: 27:{1:10089|}
+     * 2. Wakeup alarm anomaly: 35:{1:{1:{1:10013|}|}|}
+     * 3. Bluetooth anomaly:    3:{1:{1:{1:10140|}|}|}
+     */
+    @VisibleForTesting
+    final int extractUidFromStatsDimensionsValue(StatsDimensionsValue statsDimensionsValue) {
+        //TODO(b/73172999): Add robo test for this method
+        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;
+    }
+}