Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 761d3ff0 authored by Amith Yamasani's avatar Amith Yamasani
Browse files

Duration format for tunable settings 

For JobScheduler, DeviceIdle and AppStandby constants, allow
using a more compact format than milliseconds,
which are a PITA to calculate.

So instead of 18640000000... whatever, you can
use PT2H (for 2 hours), or P2D (for 2 days), etc.
Uses Duration.parse() to do the parsing. See Duration
for format.

Test: adb shell settings put global app_standby_constants
      screen_thresholds=0/PT2H/PT12H/P2D
Fixes: 71554131
Change-Id: I5141854ec7df6de266725a67f1f3e2a6e0b4c1c1
parent dc4cb146

core/java/android/util/KeyValueListParser.java

+23 −0
Original line number Diff line number Diff line
@@ -17,6 +17,9 @@ package android.util; 


import android.text.TextUtils;



import java.time.Duration;

import java.time.format.DateTimeParseException;



/**

 * Parses a list of key=value pairs, separated by some delimiter, and puts the results in

 * an internal Map. Values can be then queried by key, or if not found, a default value
@@ -189,4 +192,24 @@ public class KeyValueListParser { 
    public String keyAt(int index) {

        return mValues.keyAt(index);

    }



    /**

     * {@hide}

     * Parse a duration in millis based on java.time.Duration or just a number (millis)

     */

    public long getDurationMillis(String key, long def) {

        String value = mValues.get(key);

        if (value != null) {

            try {

                if (value.startsWith("P") || value.startsWith("p")) {

                    return Duration.parse(value).toMillis();

                } else {

                    return Long.parseLong(value);

                }

            } catch (NumberFormatException | DateTimeParseException e) {

                // fallthrough

            }

        }

        return def;

    }

}

services/core/java/com/android/server/DeviceIdleController.java

+23 −22
Original line number Diff line number Diff line
@@ -795,64 +795,65 @@ public class DeviceIdleController extends SystemService 
                    Slog.e(TAG, "Bad device idle settings", e);

                }



                LIGHT_IDLE_AFTER_INACTIVE_TIMEOUT = mParser.getLong(

                LIGHT_IDLE_AFTER_INACTIVE_TIMEOUT = mParser.getDurationMillis(

                        KEY_LIGHT_IDLE_AFTER_INACTIVE_TIMEOUT,

                        !COMPRESS_TIME ? 5 * 60 * 1000L : 15 * 1000L);

                LIGHT_PRE_IDLE_TIMEOUT = mParser.getLong(KEY_LIGHT_PRE_IDLE_TIMEOUT,

                LIGHT_PRE_IDLE_TIMEOUT = mParser.getDurationMillis(KEY_LIGHT_PRE_IDLE_TIMEOUT,

                        !COMPRESS_TIME ? 10 * 60 * 1000L : 30 * 1000L);

                LIGHT_IDLE_TIMEOUT = mParser.getLong(KEY_LIGHT_IDLE_TIMEOUT,

                LIGHT_IDLE_TIMEOUT = mParser.getDurationMillis(KEY_LIGHT_IDLE_TIMEOUT,

                        !COMPRESS_TIME ? 5 * 60 * 1000L : 15 * 1000L);

                LIGHT_IDLE_FACTOR = mParser.getFloat(KEY_LIGHT_IDLE_FACTOR,

                        2f);

                LIGHT_MAX_IDLE_TIMEOUT = mParser.getLong(KEY_LIGHT_MAX_IDLE_TIMEOUT,

                LIGHT_MAX_IDLE_TIMEOUT = mParser.getDurationMillis(KEY_LIGHT_MAX_IDLE_TIMEOUT,

                        !COMPRESS_TIME ? 15 * 60 * 1000L : 60 * 1000L);

                LIGHT_IDLE_MAINTENANCE_MIN_BUDGET = mParser.getLong(

                LIGHT_IDLE_MAINTENANCE_MIN_BUDGET = mParser.getDurationMillis(

                        KEY_LIGHT_IDLE_MAINTENANCE_MIN_BUDGET,

                        !COMPRESS_TIME ? 1 * 60 * 1000L : 15 * 1000L);

                LIGHT_IDLE_MAINTENANCE_MAX_BUDGET = mParser.getLong(

                LIGHT_IDLE_MAINTENANCE_MAX_BUDGET = mParser.getDurationMillis(

                        KEY_LIGHT_IDLE_MAINTENANCE_MAX_BUDGET,

                        !COMPRESS_TIME ? 5 * 60 * 1000L : 30 * 1000L);

                MIN_LIGHT_MAINTENANCE_TIME = mParser.getLong(

                MIN_LIGHT_MAINTENANCE_TIME = mParser.getDurationMillis(

                        KEY_MIN_LIGHT_MAINTENANCE_TIME,

                        !COMPRESS_TIME ? 5 * 1000L : 1 * 1000L);

                MIN_DEEP_MAINTENANCE_TIME = mParser.getLong(

                MIN_DEEP_MAINTENANCE_TIME = mParser.getDurationMillis(

                        KEY_MIN_DEEP_MAINTENANCE_TIME,

                        !COMPRESS_TIME ? 30 * 1000L : 5 * 1000L);

                long inactiveTimeoutDefault = (mSmallBatteryDevice ? 15 : 30) * 60 * 1000L;

                INACTIVE_TIMEOUT = mParser.getLong(KEY_INACTIVE_TIMEOUT,

                INACTIVE_TIMEOUT = mParser.getDurationMillis(KEY_INACTIVE_TIMEOUT,

                        !COMPRESS_TIME ? inactiveTimeoutDefault : (inactiveTimeoutDefault / 10));

                SENSING_TIMEOUT = mParser.getLong(KEY_SENSING_TIMEOUT,

                SENSING_TIMEOUT = mParser.getDurationMillis(KEY_SENSING_TIMEOUT,

                        !DEBUG ? 4 * 60 * 1000L : 60 * 1000L);

                LOCATING_TIMEOUT = mParser.getLong(KEY_LOCATING_TIMEOUT,

                LOCATING_TIMEOUT = mParser.getDurationMillis(KEY_LOCATING_TIMEOUT,

                        !DEBUG ? 30 * 1000L : 15 * 1000L);

                LOCATION_ACCURACY = mParser.getFloat(KEY_LOCATION_ACCURACY, 20);

                MOTION_INACTIVE_TIMEOUT = mParser.getLong(KEY_MOTION_INACTIVE_TIMEOUT,

                MOTION_INACTIVE_TIMEOUT = mParser.getDurationMillis(KEY_MOTION_INACTIVE_TIMEOUT,

                        !COMPRESS_TIME ? 10 * 60 * 1000L : 60 * 1000L);

                long idleAfterInactiveTimeout = (mSmallBatteryDevice ? 15 : 30) * 60 * 1000L;

                IDLE_AFTER_INACTIVE_TIMEOUT = mParser.getLong(KEY_IDLE_AFTER_INACTIVE_TIMEOUT,

                IDLE_AFTER_INACTIVE_TIMEOUT = mParser.getDurationMillis(

                        KEY_IDLE_AFTER_INACTIVE_TIMEOUT,

                        !COMPRESS_TIME ? idleAfterInactiveTimeout

                                       : (idleAfterInactiveTimeout / 10));

                IDLE_PENDING_TIMEOUT = mParser.getLong(KEY_IDLE_PENDING_TIMEOUT,

                IDLE_PENDING_TIMEOUT = mParser.getDurationMillis(KEY_IDLE_PENDING_TIMEOUT,

                        !COMPRESS_TIME ? 5 * 60 * 1000L : 30 * 1000L);

                MAX_IDLE_PENDING_TIMEOUT = mParser.getLong(KEY_MAX_IDLE_PENDING_TIMEOUT,

                MAX_IDLE_PENDING_TIMEOUT = mParser.getDurationMillis(KEY_MAX_IDLE_PENDING_TIMEOUT,

                        !COMPRESS_TIME ? 10 * 60 * 1000L : 60 * 1000L);

                IDLE_PENDING_FACTOR = mParser.getFloat(KEY_IDLE_PENDING_FACTOR,

                        2f);

                IDLE_TIMEOUT = mParser.getLong(KEY_IDLE_TIMEOUT,

                IDLE_TIMEOUT = mParser.getDurationMillis(KEY_IDLE_TIMEOUT,

                        !COMPRESS_TIME ? 60 * 60 * 1000L : 6 * 60 * 1000L);

                MAX_IDLE_TIMEOUT = mParser.getLong(KEY_MAX_IDLE_TIMEOUT,

                MAX_IDLE_TIMEOUT = mParser.getDurationMillis(KEY_MAX_IDLE_TIMEOUT,

                        !COMPRESS_TIME ? 6 * 60 * 60 * 1000L : 30 * 60 * 1000L);

                IDLE_FACTOR = mParser.getFloat(KEY_IDLE_FACTOR,

                        2f);

                MIN_TIME_TO_ALARM = mParser.getLong(KEY_MIN_TIME_TO_ALARM,

                MIN_TIME_TO_ALARM = mParser.getDurationMillis(KEY_MIN_TIME_TO_ALARM,

                        !COMPRESS_TIME ? 60 * 60 * 1000L : 6 * 60 * 1000L);

                MAX_TEMP_APP_WHITELIST_DURATION = mParser.getLong(

                MAX_TEMP_APP_WHITELIST_DURATION = mParser.getDurationMillis(

                        KEY_MAX_TEMP_APP_WHITELIST_DURATION, 5 * 60 * 1000L);

                MMS_TEMP_APP_WHITELIST_DURATION = mParser.getLong(

                MMS_TEMP_APP_WHITELIST_DURATION = mParser.getDurationMillis(

                        KEY_MMS_TEMP_APP_WHITELIST_DURATION, 60 * 1000L);

                SMS_TEMP_APP_WHITELIST_DURATION = mParser.getLong(

                SMS_TEMP_APP_WHITELIST_DURATION = mParser.getDurationMillis(

                        KEY_SMS_TEMP_APP_WHITELIST_DURATION, 20 * 1000L);

                NOTIFICATION_WHITELIST_DURATION = mParser.getLong(

                NOTIFICATION_WHITELIST_DURATION = mParser.getDurationMillis(

                        KEY_NOTIFICATION_WHITELIST_DURATION, 30 * 1000L);

            }

        }

services/core/java/com/android/server/job/JobSchedulerService.java

+3 −3
Original line number Diff line number Diff line
@@ -466,11 +466,11 @@ public final class JobSchedulerService extends com.android.server.SystemService 
                        DEFAULT_MAX_STANDARD_RESCHEDULE_COUNT);

                MAX_WORK_RESCHEDULE_COUNT = mParser.getInt(KEY_MAX_WORK_RESCHEDULE_COUNT,

                        DEFAULT_MAX_WORK_RESCHEDULE_COUNT);

                MIN_LINEAR_BACKOFF_TIME = mParser.getLong(KEY_MIN_LINEAR_BACKOFF_TIME,

                MIN_LINEAR_BACKOFF_TIME = mParser.getDurationMillis(KEY_MIN_LINEAR_BACKOFF_TIME,

                        DEFAULT_MIN_LINEAR_BACKOFF_TIME);

                MIN_EXP_BACKOFF_TIME = mParser.getLong(KEY_MIN_EXP_BACKOFF_TIME,

                MIN_EXP_BACKOFF_TIME = mParser.getDurationMillis(KEY_MIN_EXP_BACKOFF_TIME,

                        DEFAULT_MIN_EXP_BACKOFF_TIME);

                STANDBY_HEARTBEAT_TIME = mParser.getLong(KEY_STANDBY_HEARTBEAT_TIME,

                STANDBY_HEARTBEAT_TIME = mParser.getDurationMillis(KEY_STANDBY_HEARTBEAT_TIME,

                        DEFAULT_STANDBY_HEARTBEAT_TIME);

                STANDBY_BEATS[1] = mParser.getInt(KEY_STANDBY_WORKING_BEATS,

                        DEFAULT_STANDBY_WORKING_BEATS);

services/usage/java/com/android/server/usage/AppStandbyController.java

+13 −4
Original line number Diff line number Diff line
@@ -36,7 +36,6 @@ import android.app.AppGlobals; 
import android.app.admin.DevicePolicyManager;

import android.app.usage.UsageStatsManager.StandbyBuckets;

import android.app.usage.UsageEvents;

import android.app.usage.UsageStatsManager;

import android.app.usage.UsageStatsManagerInternal.AppIdleStateChangeListener;

import android.appwidget.AppWidgetManager;

import android.content.BroadcastReceiver;
@@ -82,6 +81,8 @@ import com.android.server.LocalServices; 


import java.io.File;

import java.io.PrintWriter;

import java.time.Duration;

import java.time.format.DateTimeParseException;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;
@@ -1278,10 +1279,10 @@ public class AppStandbyController { 
            synchronized (mAppIdleLock) {



                // Default: 24 hours between paroles

                mAppIdleParoleIntervalMillis = mParser.getLong(KEY_PAROLE_INTERVAL,

                mAppIdleParoleIntervalMillis = mParser.getDurationMillis(KEY_PAROLE_INTERVAL,

                        COMPRESS_TIME ? ONE_MINUTE * 10 : 24 * 60 * ONE_MINUTE);



                mAppIdleParoleDurationMillis = mParser.getLong(KEY_PAROLE_DURATION,

                mAppIdleParoleDurationMillis = mParser.getDurationMillis(KEY_PAROLE_DURATION,

                        COMPRESS_TIME ? ONE_MINUTE : 10 * ONE_MINUTE); // 10 minutes



                String screenThresholdsValue = mParser.getString(KEY_SCREEN_TIME_THRESHOLDS, null);
@@ -1308,8 +1309,16 @@ public class AppStandbyController { 
                if (thresholds.length == THRESHOLD_BUCKETS.length) {

                    long[] array = new long[THRESHOLD_BUCKETS.length];

                    for (int i = 0; i < THRESHOLD_BUCKETS.length; i++) {

                        try {

                            if (thresholds[i].startsWith("P") || thresholds[i].startsWith("p")) {

                                array[i] = Duration.parse(thresholds[i]).toMillis();

                            } else {

                                array[i] = Long.parseLong(thresholds[i]);

                            }

                        } catch (NumberFormatException|DateTimeParseException e) {

                            return defaults;

                        }

                    }

                    return array;

                } else {

                    return defaults;