1 /* 2 * Copyright (C) 2017 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.android.server.am; 18 19 import static android.os.PowerExemptionManager.TEMPORARY_ALLOW_LIST_TYPE_FOREGROUND_SERVICE_NOT_ALLOWED; 20 import static android.os.PowerExemptionManager.TEMPORARY_ALLOW_LIST_TYPE_NONE; 21 22 import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_POWER_QUICK; 23 import static com.android.server.am.BroadcastConstants.DEFER_BOOT_COMPLETED_BROADCAST_BACKGROUND_RESTRICTED_ONLY; 24 import static com.android.server.am.BroadcastConstants.DEFER_BOOT_COMPLETED_BROADCAST_TARGET_T_ONLY; 25 26 import android.annotation.NonNull; 27 import android.app.ActivityThread; 28 import android.content.ComponentName; 29 import android.content.ContentResolver; 30 import android.content.Context; 31 import android.database.ContentObserver; 32 import android.net.Uri; 33 import android.os.Build; 34 import android.os.Handler; 35 import android.os.Message; 36 import android.os.PowerExemptionManager; 37 import android.os.SystemClock; 38 import android.provider.DeviceConfig; 39 import android.provider.DeviceConfig.OnPropertiesChangedListener; 40 import android.provider.DeviceConfig.Properties; 41 import android.provider.Settings; 42 import android.text.TextUtils; 43 import android.util.ArraySet; 44 import android.util.KeyValueListParser; 45 import android.util.Slog; 46 47 import com.android.internal.annotations.GuardedBy; 48 49 import dalvik.annotation.optimization.NeverCompile; 50 51 import java.io.PrintWriter; 52 import java.util.Arrays; 53 import java.util.List; 54 import java.util.stream.Collectors; 55 56 /** 57 * Settings constants that can modify the activity manager's behavior. 58 */ 59 final class ActivityManagerConstants extends ContentObserver { 60 private static final String TAG = "ActivityManagerConstants"; 61 62 // Key names stored in the settings value. 63 static final String KEY_BACKGROUND_SETTLE_TIME = "background_settle_time"; 64 65 private static final String KEY_FGSERVICE_MIN_SHOWN_TIME 66 = "fgservice_min_shown_time"; 67 private static final String KEY_FGSERVICE_MIN_REPORT_TIME 68 = "fgservice_min_report_time"; 69 private static final String KEY_FGSERVICE_SCREEN_ON_BEFORE_TIME 70 = "fgservice_screen_on_before_time"; 71 private static final String KEY_FGSERVICE_SCREEN_ON_AFTER_TIME 72 = "fgservice_screen_on_after_time"; 73 private static final String KEY_CONTENT_PROVIDER_RETAIN_TIME = "content_provider_retain_time"; 74 private static final String KEY_GC_TIMEOUT = "gc_timeout"; 75 private static final String KEY_GC_MIN_INTERVAL = "gc_min_interval"; 76 private static final String KEY_FORCE_BACKGROUND_CHECK_ON_RESTRICTED_APPS = 77 "force_bg_check_on_restricted"; 78 private static final String KEY_FULL_PSS_MIN_INTERVAL = "full_pss_min_interval"; 79 private static final String KEY_FULL_PSS_LOWERED_INTERVAL = "full_pss_lowered_interval"; 80 private static final String KEY_POWER_CHECK_INTERVAL = "power_check_interval"; 81 private static final String KEY_POWER_CHECK_MAX_CPU_1 = "power_check_max_cpu_1"; 82 private static final String KEY_POWER_CHECK_MAX_CPU_2 = "power_check_max_cpu_2"; 83 private static final String KEY_POWER_CHECK_MAX_CPU_3 = "power_check_max_cpu_3"; 84 private static final String KEY_POWER_CHECK_MAX_CPU_4 = "power_check_max_cpu_4"; 85 /** Used for all apps on R and earlier versions. */ 86 private static final String KEY_SERVICE_USAGE_INTERACTION_TIME_PRE_S = 87 "service_usage_interaction_time"; 88 private static final String KEY_SERVICE_USAGE_INTERACTION_TIME_POST_S = 89 "service_usage_interaction_time_post_s"; 90 /** Used for all apps on R and earlier versions. */ 91 private static final String KEY_USAGE_STATS_INTERACTION_INTERVAL_PRE_S = 92 "usage_stats_interaction_interval"; 93 private static final String KEY_USAGE_STATS_INTERACTION_INTERVAL_POST_S = 94 "usage_stats_interaction_interval_post_s"; 95 private static final String KEY_IMPERCEPTIBLE_KILL_EXEMPT_PACKAGES = 96 "imperceptible_kill_exempt_packages"; 97 private static final String KEY_IMPERCEPTIBLE_KILL_EXEMPT_PROC_STATES = 98 "imperceptible_kill_exempt_proc_states"; 99 static final String KEY_SERVICE_RESTART_DURATION = "service_restart_duration"; 100 static final String KEY_SERVICE_RESET_RUN_DURATION = "service_reset_run_duration"; 101 static final String KEY_SERVICE_RESTART_DURATION_FACTOR = "service_restart_duration_factor"; 102 static final String KEY_SERVICE_MIN_RESTART_TIME_BETWEEN = "service_min_restart_time_between"; 103 static final String KEY_MAX_SERVICE_INACTIVITY = "service_max_inactivity"; 104 static final String KEY_BG_START_TIMEOUT = "service_bg_start_timeout"; 105 static final String KEY_SERVICE_BG_ACTIVITY_START_TIMEOUT = "service_bg_activity_start_timeout"; 106 static final String KEY_BOUND_SERVICE_CRASH_RESTART_DURATION = "service_crash_restart_duration"; 107 static final String KEY_BOUND_SERVICE_CRASH_MAX_RETRY = "service_crash_max_retry"; 108 static final String KEY_PROCESS_START_ASYNC = "process_start_async"; 109 static final String KEY_MEMORY_INFO_THROTTLE_TIME = "memory_info_throttle_time"; 110 static final String KEY_TOP_TO_FGS_GRACE_DURATION = "top_to_fgs_grace_duration"; 111 static final String KEY_TOP_TO_ALMOST_PERCEPTIBLE_GRACE_DURATION = 112 "top_to_almost_perceptible_grace_duration"; 113 static final String KEY_PENDINGINTENT_WARNING_THRESHOLD = "pendingintent_warning_threshold"; 114 static final String KEY_MIN_CRASH_INTERVAL = "min_crash_interval"; 115 static final String KEY_PROCESS_CRASH_COUNT_RESET_INTERVAL = 116 "process_crash_count_reset_interval"; 117 static final String KEY_PROCESS_CRASH_COUNT_LIMIT = "process_crash_count_limit"; 118 static final String KEY_BOOT_TIME_TEMP_ALLOWLIST_DURATION = "boot_time_temp_allowlist_duration"; 119 static final String KEY_FG_TO_BG_FGS_GRACE_DURATION = "fg_to_bg_fgs_grace_duration"; 120 static final String KEY_FGS_START_FOREGROUND_TIMEOUT = "fgs_start_foreground_timeout"; 121 static final String KEY_FGS_ATOM_SAMPLE_RATE = "fgs_atom_sample_rate"; 122 static final String KEY_FGS_START_ALLOWED_LOG_SAMPLE_RATE = "fgs_start_allowed_log_sample_rate"; 123 static final String KEY_FGS_START_DENIED_LOG_SAMPLE_RATE = "fgs_start_denied_log_sample_rate"; 124 static final String KEY_FGS_ALLOW_OPT_OUT = "fgs_allow_opt_out"; 125 static final String KEY_EXTRA_SERVICE_RESTART_DELAY_ON_MEM_PRESSURE = 126 "extra_delay_svc_restart_mem_pressure"; 127 static final String KEY_ENABLE_EXTRA_SERVICE_RESTART_DELAY_ON_MEM_PRESSURE = 128 "enable_extra_delay_svc_restart_mem_pressure"; 129 static final String KEY_KILL_BG_RESTRICTED_CACHED_IDLE = "kill_bg_restricted_cached_idle"; 130 static final String KEY_KILL_BG_RESTRICTED_CACHED_IDLE_SETTLE_TIME = 131 "kill_bg_restricted_cached_idle_settle_time"; 132 /** 133 * Note this key is on {@link DeviceConfig#NAMESPACE_ACTIVITY_MANAGER_COMPONENT_ALIAS}. 134 * @see #mEnableComponentAlias 135 */ 136 static final String KEY_ENABLE_COMPONENT_ALIAS = "enable_experimental_component_alias"; 137 /** 138 * Note this key is on {@link DeviceConfig#NAMESPACE_ACTIVITY_MANAGER_COMPONENT_ALIAS}. 139 * @see #mComponentAliasOverrides 140 */ 141 static final String KEY_COMPONENT_ALIAS_OVERRIDES = "component_alias_overrides"; 142 143 /** 144 * Indicates the maximum time that an app is blocked for the network rules to get updated. 145 */ 146 static final String KEY_NETWORK_ACCESS_TIMEOUT_MS = "network_access_timeout_ms"; 147 148 private static final int DEFAULT_MAX_CACHED_PROCESSES = 32; 149 private static final long DEFAULT_FGSERVICE_MIN_SHOWN_TIME = 2*1000; 150 private static final long DEFAULT_FGSERVICE_MIN_REPORT_TIME = 3*1000; 151 private static final long DEFAULT_FGSERVICE_SCREEN_ON_BEFORE_TIME = 1*1000; 152 private static final long DEFAULT_FGSERVICE_SCREEN_ON_AFTER_TIME = 5*1000; 153 private static final long DEFAULT_CONTENT_PROVIDER_RETAIN_TIME = 20*1000; 154 private static final long DEFAULT_GC_TIMEOUT = 5*1000; 155 private static final long DEFAULT_GC_MIN_INTERVAL = 60*1000; 156 private static final long DEFAULT_FULL_PSS_MIN_INTERVAL = 20*60*1000; 157 private static final boolean DEFAULT_FORCE_BACKGROUND_CHECK_ON_RESTRICTED_APPS = true; 158 private static final long DEFAULT_FULL_PSS_LOWERED_INTERVAL = 5*60*1000; 159 private static final long DEFAULT_POWER_CHECK_INTERVAL = (DEBUG_POWER_QUICK ? 1 : 5) * 60*1000; 160 private static final int DEFAULT_POWER_CHECK_MAX_CPU_1 = 25; 161 private static final int DEFAULT_POWER_CHECK_MAX_CPU_2 = 25; 162 private static final int DEFAULT_POWER_CHECK_MAX_CPU_3 = 10; 163 private static final int DEFAULT_POWER_CHECK_MAX_CPU_4 = 2; 164 private static final long DEFAULT_SERVICE_USAGE_INTERACTION_TIME_PRE_S = 30 * 60 * 1000; 165 private static final long DEFAULT_SERVICE_USAGE_INTERACTION_TIME_POST_S = 60 * 1000; 166 private static final long DEFAULT_USAGE_STATS_INTERACTION_INTERVAL_PRE_S = 2 * 60 * 60 * 1000; 167 private static final long DEFAULT_USAGE_STATS_INTERACTION_INTERVAL_POST_S = 10 * 60 * 1000; 168 private static final long DEFAULT_SERVICE_RESTART_DURATION = 1*1000; 169 private static final long DEFAULT_SERVICE_RESET_RUN_DURATION = 60*1000; 170 private static final int DEFAULT_SERVICE_RESTART_DURATION_FACTOR = 4; 171 private static final long DEFAULT_SERVICE_MIN_RESTART_TIME_BETWEEN = 10*1000; 172 private static final long DEFAULT_MAX_SERVICE_INACTIVITY = 30*60*1000; 173 private static final long DEFAULT_BG_START_TIMEOUT = 15*1000; 174 private static final long DEFAULT_SERVICE_BG_ACTIVITY_START_TIMEOUT = 10_000; 175 private static final long DEFAULT_BOUND_SERVICE_CRASH_RESTART_DURATION = 30*60_000; 176 private static final int DEFAULT_BOUND_SERVICE_CRASH_MAX_RETRY = 16; 177 private static final boolean DEFAULT_PROCESS_START_ASYNC = true; 178 private static final long DEFAULT_MEMORY_INFO_THROTTLE_TIME = 5*60*1000; 179 private static final long DEFAULT_TOP_TO_FGS_GRACE_DURATION = 15 * 1000; 180 private static final long DEFAULT_TOP_TO_ALMOST_PERCEPTIBLE_GRACE_DURATION = 15 * 1000; 181 private static final int DEFAULT_PENDINGINTENT_WARNING_THRESHOLD = 2000; 182 private static final int DEFAULT_MIN_CRASH_INTERVAL = 2 * 60 * 1000; 183 private static final int DEFAULT_MAX_PHANTOM_PROCESSES = 32; 184 private static final int DEFAULT_PROCESS_CRASH_COUNT_RESET_INTERVAL = 12 * 60 * 60 * 1000; 185 private static final int DEFAULT_PROCESS_CRASH_COUNT_LIMIT = 12; 186 private static final int DEFAULT_BOOT_TIME_TEMP_ALLOWLIST_DURATION = 20 * 1000; 187 private static final long DEFAULT_FG_TO_BG_FGS_GRACE_DURATION = 5 * 1000; 188 private static final int DEFAULT_FGS_START_FOREGROUND_TIMEOUT_MS = 10 * 1000; 189 private static final float DEFAULT_FGS_ATOM_SAMPLE_RATE = 1; // 100 % 190 private static final float DEFAULT_FGS_START_ALLOWED_LOG_SAMPLE_RATE = 0.25f; // 25% 191 private static final float DEFAULT_FGS_START_DENIED_LOG_SAMPLE_RATE = 1; // 100% 192 private static final long DEFAULT_PROCESS_KILL_TIMEOUT_MS = 10 * 1000; 193 private static final long DEFAULT_NETWORK_ACCESS_TIMEOUT_MS = 200; // 0.2 sec 194 195 static final long DEFAULT_BACKGROUND_SETTLE_TIME = 60 * 1000; 196 static final long DEFAULT_KILL_BG_RESTRICTED_CACHED_IDLE_SETTLE_TIME_MS = 60 * 1000; 197 static final boolean DEFAULT_KILL_BG_RESTRICTED_CACHED_IDLE = true; 198 199 /** 200 * Same as {@link TEMPORARY_ALLOW_LIST_TYPE_FOREGROUND_SERVICE_NOT_ALLOWED} 201 */ 202 private static final int 203 DEFAULT_PUSH_MESSAGING_OVER_QUOTA_BEHAVIOR = 1; 204 private static final boolean DEFAULT_FGS_ALLOW_OPT_OUT = false; 205 206 /** 207 * The extra delays we're putting to service restarts, based on current memory pressure. 208 */ 209 private static final long DEFAULT_EXTRA_SERVICE_RESTART_DELAY_ON_NORMAL_MEM = 0; // ms 210 private static final long DEFAULT_EXTRA_SERVICE_RESTART_DELAY_ON_MODERATE_MEM = 10000; // ms 211 private static final long DEFAULT_EXTRA_SERVICE_RESTART_DELAY_ON_LOW_MEM = 20000; // ms 212 private static final long DEFAULT_EXTRA_SERVICE_RESTART_DELAY_ON_CRITICAL_MEM = 30000; // ms 213 private static final long[] DEFAULT_EXTRA_SERVICE_RESTART_DELAY_ON_MEM_PRESSURE = { 214 DEFAULT_EXTRA_SERVICE_RESTART_DELAY_ON_NORMAL_MEM, 215 DEFAULT_EXTRA_SERVICE_RESTART_DELAY_ON_MODERATE_MEM, 216 DEFAULT_EXTRA_SERVICE_RESTART_DELAY_ON_LOW_MEM, 217 DEFAULT_EXTRA_SERVICE_RESTART_DELAY_ON_CRITICAL_MEM, 218 }; 219 220 /** 221 * Whether or not to enable the extra delays to service restarts on memory pressure. 222 */ 223 private static final boolean DEFAULT_ENABLE_EXTRA_SERVICE_RESTART_DELAY_ON_MEM_PRESSURE = true; 224 private static final boolean DEFAULT_ENABLE_COMPONENT_ALIAS = false; 225 private static final String DEFAULT_COMPONENT_ALIAS_OVERRIDES = ""; 226 227 private static final int DEFAULT_DEFER_BOOT_COMPLETED_BROADCAST = 228 DEFER_BOOT_COMPLETED_BROADCAST_BACKGROUND_RESTRICTED_ONLY 229 | DEFER_BOOT_COMPLETED_BROADCAST_TARGET_T_ONLY; 230 231 private static final int DEFAULT_SERVICE_START_FOREGROUND_TIMEOUT_MS = 30 * 1000; 232 233 private static final int DEFAULT_SERVICE_START_FOREGROUND_ANR_DELAY_MS = 10 * 1000; 234 235 private static final long DEFAULT_SERVICE_BIND_ALMOST_PERCEPTIBLE_TIMEOUT_MS = 15 * 1000; 236 237 // Flag stored in the DeviceConfig API. 238 /** 239 * Maximum number of cached processes. 240 */ 241 private static final String KEY_MAX_CACHED_PROCESSES = "max_cached_processes"; 242 243 /** 244 * Maximum number of cached processes. 245 */ 246 private static final String KEY_MAX_PHANTOM_PROCESSES = "max_phantom_processes"; 247 248 /** 249 * Enables proactive killing of cached apps 250 */ 251 private static final String KEY_PROACTIVE_KILLS_ENABLED = "proactive_kills_enabled"; 252 253 /** 254 * Trim LRU cached app when swap falls below this minimum percentage. 255 * 256 * Depends on KEY_PROACTIVE_KILLS_ENABLED 257 */ 258 private static final String KEY_LOW_SWAP_THRESHOLD_PERCENT = "low_swap_threshold_percent"; 259 260 /** 261 * Default value for mFlagBackgroundActivityStartsEnabled if not explicitly set in 262 * Settings.Global. This allows it to be set experimentally unless it has been 263 * enabled/disabled in developer options. Defaults to false. 264 */ 265 private static final String KEY_DEFAULT_BACKGROUND_ACTIVITY_STARTS_ENABLED = 266 "default_background_activity_starts_enabled"; 267 268 /** 269 * Default value for mFlagBackgroundFgsStartRestrictionEnabled if not explicitly set in 270 * Settings.Global. 271 */ 272 private static final String KEY_DEFAULT_BACKGROUND_FGS_STARTS_RESTRICTION_ENABLED = 273 "default_background_fgs_starts_restriction_enabled"; 274 275 /** 276 * Default value for mFlagFgsStartRestrictionEnabled if not explicitly set in 277 * Settings.Global. 278 */ 279 private static final String KEY_DEFAULT_FGS_STARTS_RESTRICTION_ENABLED = 280 "default_fgs_starts_restriction_enabled"; 281 282 /** 283 * Default value for mFgsStartRestrictionNotificationEnabled if not explicitly set in 284 * Settings.Global. 285 */ 286 private static final String KEY_DEFAULT_FGS_STARTS_RESTRICTION_NOTIFICATION_ENABLED = 287 "default_fgs_starts_restriction_notification_enabled"; 288 289 /** 290 * Default value for mFgsStartRestrictionCheckCallerTargetSdk if not explicitly set in 291 * Settings.Global. 292 */ 293 private static final String KEY_DEFAULT_FGS_STARTS_RESTRICTION_CHECK_CALLER_TARGET_SDK = 294 "default_fgs_starts_restriction_check_caller_target_sdk"; 295 296 /** 297 * Whether FGS notification display is deferred following the transition into 298 * the foreground state. Default behavior is {@code true} unless overridden. 299 */ 300 private static final String KEY_DEFERRED_FGS_NOTIFICATIONS_ENABLED = 301 "deferred_fgs_notifications_enabled"; 302 303 /** Whether FGS notification deferral applies only to those apps targeting 304 * API version S or higher. Default is {@code true} unless overidden. 305 */ 306 private static final String KEY_DEFERRED_FGS_NOTIFICATIONS_API_GATED = 307 "deferred_fgs_notifications_api_gated"; 308 309 /** 310 * Time in milliseconds to defer display of FGS notifications following the 311 * transition into the foreground state. Default is 10_000 (ten seconds) 312 * unless overridden. 313 */ 314 private static final String KEY_DEFERRED_FGS_NOTIFICATION_INTERVAL = 315 "deferred_fgs_notification_interval"; 316 317 /** 318 * Time in milliseconds; once an FGS notification for a given uid has been 319 * deferred, no subsequent FGS notification from that uid will be deferred 320 * until this amount of time has passed. Default is two minutes 321 * (2 * 60 * 1000) unless overridden. 322 */ 323 private static final String KEY_DEFERRED_FGS_NOTIFICATION_EXCLUSION_TIME = 324 "deferred_fgs_notification_exclusion_time"; 325 326 /** 327 * Default value for mPushMessagingOverQuotaBehavior if not explicitly set in 328 * Settings.Global. 329 */ 330 private static final String KEY_PUSH_MESSAGING_OVER_QUOTA_BEHAVIOR = 331 "push_messaging_over_quota_behavior"; 332 333 /** 334 * Time in milliseconds; the allowed duration from a process is killed until it's really gone. 335 */ 336 private static final String KEY_PROCESS_KILL_TIMEOUT = "process_kill_timeout"; 337 338 private static final String KEY_DEFER_BOOT_COMPLETED_BROADCAST = 339 "defer_boot_completed_broadcast"; 340 341 private static final String KEY_SERVICE_START_FOREGROUND_TIMEOUT_MS = 342 "service_start_foreground_timeout_ms"; 343 344 private static final String KEY_SERVICE_START_FOREGROUND_ANR_DELAY_MS = 345 "service_start_foreground_anr_delay_ms"; 346 347 private static final String KEY_SERVICE_BIND_ALMOST_PERCEPTIBLE_TIMEOUT_MS = 348 "service_bind_almost_perceptible_timeout_ms"; 349 350 // Maximum number of cached processes we will allow. 351 public int MAX_CACHED_PROCESSES = DEFAULT_MAX_CACHED_PROCESSES; 352 353 // This is the amount of time we allow an app to settle after it goes into the background, 354 // before we start restricting what it can do. 355 public long BACKGROUND_SETTLE_TIME = DEFAULT_BACKGROUND_SETTLE_TIME; 356 357 // The minimum time we allow a foreground service to run with a notification and the 358 // screen on without otherwise telling the user about it. (If it runs for less than this, 359 // it will still be reported to the user as a running app for at least this amount of time.) 360 public long FGSERVICE_MIN_SHOWN_TIME = DEFAULT_FGSERVICE_MIN_SHOWN_TIME; 361 362 // If a foreground service is shown for less than FGSERVICE_MIN_SHOWN_TIME, we will display 363 // the background app running notification about it for at least this amount of time (if it 364 // is larger than the remaining shown time). 365 public long FGSERVICE_MIN_REPORT_TIME = DEFAULT_FGSERVICE_MIN_REPORT_TIME; 366 367 // The minimum amount of time the foreground service needs to have remain being shown 368 // before the screen goes on for us to consider it not worth showing to the user. That is 369 // if an app has a foreground service that stops itself this amount of time or more before 370 // the user turns on the screen, we will just let it go without the user being told about it. 371 public long FGSERVICE_SCREEN_ON_BEFORE_TIME = DEFAULT_FGSERVICE_SCREEN_ON_BEFORE_TIME; 372 373 // The minimum amount of time a foreground service should remain reported to the user if 374 // it is stopped when the screen turns on. This is the time from when the screen turns 375 // on until we will stop reporting it. 376 public long FGSERVICE_SCREEN_ON_AFTER_TIME = DEFAULT_FGSERVICE_SCREEN_ON_AFTER_TIME; 377 378 // How long we will retain processes hosting content providers in the "last activity" 379 // state before allowing them to drop down to the regular cached LRU list. This is 380 // to avoid thrashing of provider processes under low memory situations. 381 long CONTENT_PROVIDER_RETAIN_TIME = DEFAULT_CONTENT_PROVIDER_RETAIN_TIME; 382 383 // How long to wait after going idle before forcing apps to GC. 384 long GC_TIMEOUT = DEFAULT_GC_TIMEOUT; 385 386 // The minimum amount of time between successive GC requests for a process. 387 long GC_MIN_INTERVAL = DEFAULT_GC_MIN_INTERVAL; 388 389 /** 390 * Whether or not Background Check should be forced on any apps in the 391 * {@link android.app.usage.UsageStatsManager#STANDBY_BUCKET_RESTRICTED} bucket, 392 * regardless of target SDK version. 393 */ 394 boolean FORCE_BACKGROUND_CHECK_ON_RESTRICTED_APPS = 395 DEFAULT_FORCE_BACKGROUND_CHECK_ON_RESTRICTED_APPS; 396 397 // The minimum amount of time between successive PSS requests for a process. 398 long FULL_PSS_MIN_INTERVAL = DEFAULT_FULL_PSS_MIN_INTERVAL; 399 400 // The minimum amount of time between successive PSS requests for a process 401 // when the request is due to the memory state being lowered. 402 long FULL_PSS_LOWERED_INTERVAL = DEFAULT_FULL_PSS_LOWERED_INTERVAL; 403 404 // The minimum sample duration we will allow before deciding we have 405 // enough data on CPU usage to start killing things. 406 long POWER_CHECK_INTERVAL = DEFAULT_POWER_CHECK_INTERVAL; 407 408 // The maximum CPU (as a percentage) a process is allowed to use over the first 409 // power check interval that it is cached. 410 int POWER_CHECK_MAX_CPU_1 = DEFAULT_POWER_CHECK_MAX_CPU_1; 411 412 // The maximum CPU (as a percentage) a process is allowed to use over the second 413 // power check interval that it is cached. The home app will never check for less 414 // CPU than this (it will not test against the 3 or 4 levels). 415 int POWER_CHECK_MAX_CPU_2 = DEFAULT_POWER_CHECK_MAX_CPU_2; 416 417 // The maximum CPU (as a percentage) a process is allowed to use over the third 418 // power check interval that it is cached. 419 int POWER_CHECK_MAX_CPU_3 = DEFAULT_POWER_CHECK_MAX_CPU_3; 420 421 // The maximum CPU (as a percentage) a process is allowed to use over the fourth 422 // power check interval that it is cached. 423 int POWER_CHECK_MAX_CPU_4 = DEFAULT_POWER_CHECK_MAX_CPU_4; 424 425 // This is the amount of time an app needs to be running a foreground service before 426 // we will consider it to be doing interaction for usage stats. 427 // Only used for apps targeting pre-S versions. 428 long SERVICE_USAGE_INTERACTION_TIME_PRE_S = DEFAULT_SERVICE_USAGE_INTERACTION_TIME_PRE_S; 429 430 // This is the amount of time an app needs to be running a foreground service before 431 // we will consider it to be doing interaction for usage stats. 432 // Only used for apps targeting versions S and above. 433 long SERVICE_USAGE_INTERACTION_TIME_POST_S = DEFAULT_SERVICE_USAGE_INTERACTION_TIME_POST_S; 434 435 // Maximum amount of time we will allow to elapse before re-reporting usage stats 436 // interaction with foreground processes. 437 // Only used for apps targeting pre-S versions. 438 long USAGE_STATS_INTERACTION_INTERVAL_PRE_S = DEFAULT_USAGE_STATS_INTERACTION_INTERVAL_PRE_S; 439 440 // Maximum amount of time we will allow to elapse before re-reporting usage stats 441 // interaction with foreground processes. 442 // Only used for apps targeting versions S and above. 443 long USAGE_STATS_INTERACTION_INTERVAL_POST_S = DEFAULT_USAGE_STATS_INTERACTION_INTERVAL_POST_S; 444 445 // How long a service needs to be running until restarting its process 446 // is no longer considered to be a relaunch of the service. 447 public long SERVICE_RESTART_DURATION = DEFAULT_SERVICE_RESTART_DURATION; 448 449 // How long a service needs to be running until it will start back at 450 // SERVICE_RESTART_DURATION after being killed. 451 public long SERVICE_RESET_RUN_DURATION = DEFAULT_SERVICE_RESET_RUN_DURATION; 452 453 // Multiplying factor to increase restart duration time by, for each time 454 // a service is killed before it has run for SERVICE_RESET_RUN_DURATION. 455 public int SERVICE_RESTART_DURATION_FACTOR = DEFAULT_SERVICE_RESTART_DURATION_FACTOR; 456 457 // The minimum amount of time between restarting services that we allow. 458 // That is, when multiple services are restarting, we won't allow each 459 // to restart less than this amount of time from the last one. 460 public long SERVICE_MIN_RESTART_TIME_BETWEEN = DEFAULT_SERVICE_MIN_RESTART_TIME_BETWEEN; 461 462 // Maximum amount of time for there to be no activity on a service before 463 // we consider it non-essential and allow its process to go on the 464 // LRU background list. 465 public long MAX_SERVICE_INACTIVITY = DEFAULT_MAX_SERVICE_INACTIVITY; 466 467 // How long we wait for a background started service to stop itself before 468 // allowing the next pending start to run. 469 public long BG_START_TIMEOUT = DEFAULT_BG_START_TIMEOUT; 470 471 // For a service that has been allowed to start background activities, how long after it started 472 // its process can start a background activity. 473 public long SERVICE_BG_ACTIVITY_START_TIMEOUT = DEFAULT_SERVICE_BG_ACTIVITY_START_TIMEOUT; 474 475 // Initial backoff delay for retrying bound foreground services 476 public long BOUND_SERVICE_CRASH_RESTART_DURATION = DEFAULT_BOUND_SERVICE_CRASH_RESTART_DURATION; 477 478 // Maximum number of retries for bound foreground services that crash soon after start 479 public long BOUND_SERVICE_MAX_CRASH_RETRY = DEFAULT_BOUND_SERVICE_CRASH_MAX_RETRY; 480 481 // Indicates if the processes need to be started asynchronously. 482 public boolean FLAG_PROCESS_START_ASYNC = DEFAULT_PROCESS_START_ASYNC; 483 484 // The minimum time we allow between requests for the MemoryInfo of a process to 485 // throttle requests from apps. 486 public long MEMORY_INFO_THROTTLE_TIME = DEFAULT_MEMORY_INFO_THROTTLE_TIME; 487 488 // Allow app just moving from TOP to FOREGROUND_SERVICE to stay in a higher adj value for 489 // this long. 490 public long TOP_TO_FGS_GRACE_DURATION = DEFAULT_TOP_TO_FGS_GRACE_DURATION; 491 492 /** 493 * Allow app just leaving TOP with an already running ALMOST_PERCEPTIBLE service to stay in 494 * a higher adj value for this long. 495 */ 496 public long TOP_TO_ALMOST_PERCEPTIBLE_GRACE_DURATION = 497 DEFAULT_TOP_TO_ALMOST_PERCEPTIBLE_GRACE_DURATION; 498 499 /** 500 * The minimum time we allow between crashes, for us to consider this 501 * application to be bad and stop its services and reject broadcasts. 502 * A reasonable interval here would be anything between 1-3 minutes. 503 */ 504 public static int MIN_CRASH_INTERVAL = DEFAULT_MIN_CRASH_INTERVAL; 505 506 /** 507 * We will allow for a maximum number of {@link PROCESS_CRASH_COUNT_LIMIT} crashes within this 508 * time period before we consider the application to be bad and stop services and reject 509 * broadcasts. 510 * A reasonable reset interval here would be anything between 10-20 hours along with a crash 511 * count limit of 10-20 crashes. 512 */ 513 static long PROCESS_CRASH_COUNT_RESET_INTERVAL = DEFAULT_PROCESS_CRASH_COUNT_RESET_INTERVAL; 514 515 /** 516 * The maximum number of crashes allowed within {@link PROCESS_CRASH_COUNT_RESET_INTERVAL_MS} 517 * before we consider the application to be bad and stop services and reject broadcasts. 518 * A reasonable crash count limit here would be anything between 10-20 crashes along with a 519 * reset interval of 10-20 hours. 520 */ 521 static int PROCESS_CRASH_COUNT_LIMIT = DEFAULT_PROCESS_CRASH_COUNT_LIMIT; 522 523 // Indicates whether the activity starts logging is enabled. 524 // Controlled by Settings.Global.ACTIVITY_STARTS_LOGGING_ENABLED 525 volatile boolean mFlagActivityStartsLoggingEnabled; 526 527 // Indicates whether the background activity starts is enabled. 528 // Controlled by Settings.Global.BACKGROUND_ACTIVITY_STARTS_ENABLED. 529 // If not set explicitly the default is controlled by DeviceConfig. 530 volatile boolean mFlagBackgroundActivityStartsEnabled; 531 532 // Indicates whether foreground service starts logging is enabled. 533 // Controlled by Settings.Global.FOREGROUND_SERVICE_STARTS_LOGGING_ENABLED 534 volatile boolean mFlagForegroundServiceStartsLoggingEnabled; 535 536 // Indicates whether the foreground service background start restriction is enabled. 537 // When the restriction is enabled, foreground service started from background will not have 538 // while-in-use permissions like location, camera and microphone. (The foreground service can be 539 // started, the restriction is on while-in-use permissions.) 540 volatile boolean mFlagBackgroundFgsStartRestrictionEnabled = true; 541 542 // Indicates whether the foreground service background start restriction is enabled for 543 // apps targeting S+. 544 // When the restriction is enabled, service is not allowed to startForeground from background 545 // at all. 546 volatile boolean mFlagFgsStartRestrictionEnabled = true; 547 548 // Whether to display a notification when a service is restricted from startForeground due to 549 // foreground service background start restriction. 550 volatile boolean mFgsStartRestrictionNotificationEnabled = false; 551 552 /** 553 * Indicates whether the foreground service background start restriction is enabled for 554 * caller app that is targeting S+. 555 * This is in addition to check of {@link #mFlagFgsStartRestrictionEnabled} flag. 556 */ 557 volatile boolean mFgsStartRestrictionCheckCallerTargetSdk = true; 558 559 // Whether we defer FGS notifications a few seconds following their transition to 560 // the foreground state. Applies only to S+ apps; enabled by default. 561 volatile boolean mFlagFgsNotificationDeferralEnabled = true; 562 563 // Restrict FGS notification deferral policy to only those apps that target 564 // API version S or higher. Disabled by default; set to "true" to force 565 // legacy app FGS notifications to display immediately in all cases. 566 volatile boolean mFlagFgsNotificationDeferralApiGated = false; 567 568 // Time in milliseconds to defer FGS notifications after their transition to 569 // the foreground state. 570 volatile long mFgsNotificationDeferralInterval = 10_000; 571 572 // Rate limit: minimum time after an app's FGS notification is deferred 573 // before another FGS notification from that app can be deferred. 574 volatile long mFgsNotificationDeferralExclusionTime = 2 * 60 * 1000L; 575 576 /** 577 * When server pushing message is over the quote, select one of the temp allow list type as 578 * defined in {@link PowerExemptionManager.TempAllowListType} 579 */ 580 volatile @PowerExemptionManager.TempAllowListType int mPushMessagingOverQuotaBehavior = 581 DEFAULT_PUSH_MESSAGING_OVER_QUOTA_BEHAVIOR; 582 583 /* 584 * At boot time, broadcast receiver ACTION_BOOT_COMPLETED, ACTION_LOCKED_BOOT_COMPLETED and 585 * ACTION_PRE_BOOT_COMPLETED are temp allowlisted to start FGS for a duration of time in 586 * milliseconds. 587 */ 588 volatile long mBootTimeTempAllowlistDuration = DEFAULT_BOOT_TIME_TEMP_ALLOWLIST_DURATION; 589 590 /** 591 * The grace period in milliseconds to allow a process to start FGS from background after 592 * switching from foreground to background; currently it's only applicable to its activities. 593 */ 594 volatile long mFgToBgFgsGraceDuration = DEFAULT_FG_TO_BG_FGS_GRACE_DURATION; 595 596 /** 597 * When service started from background, before the timeout it can be promoted to FGS by calling 598 * Service.startForeground(). 599 */ 600 volatile long mFgsStartForegroundTimeoutMs = DEFAULT_FGS_START_FOREGROUND_TIMEOUT_MS; 601 602 /** 603 * Sample rate for the FGS atom. 604 * 605 * If the value is 0.1, 10% of the installed packages would be sampled. 606 */ 607 volatile float mFgsAtomSampleRate = DEFAULT_FGS_ATOM_SAMPLE_RATE; 608 609 /** 610 * Sample rate for the allowed FGS start WTF logs. 611 * 612 * If the value is 0.1, 10% of the logs would be sampled. 613 */ 614 volatile float mFgsStartAllowedLogSampleRate = DEFAULT_FGS_START_ALLOWED_LOG_SAMPLE_RATE; 615 616 /** 617 * Sample rate for the denied FGS start WTF logs. 618 * 619 * If the value is 0.1, 10% of the logs would be sampled. 620 */ 621 volatile float mFgsStartDeniedLogSampleRate = DEFAULT_FGS_START_DENIED_LOG_SAMPLE_RATE; 622 623 /** 624 * Whether or not to kill apps in background restricted mode and it's cached, its UID state is 625 * idle. 626 */ 627 volatile boolean mKillBgRestrictedAndCachedIdle = DEFAULT_KILL_BG_RESTRICTED_CACHED_IDLE; 628 629 /** 630 * The amount of time we allow an app in background restricted mode to settle after it goes 631 * into the cached & UID idle, before we decide to kill it. 632 */ 633 volatile long mKillBgRestrictedAndCachedIdleSettleTimeMs = 634 DEFAULT_KILL_BG_RESTRICTED_CACHED_IDLE_SETTLE_TIME_MS; 635 636 /** 637 * The allowed duration from a process is killed until it's really gone. 638 */ 639 volatile long mProcessKillTimeoutMs = DEFAULT_PROCESS_KILL_TIMEOUT_MS; 640 641 /** 642 * Whether to allow "opt-out" from the foreground service restrictions. 643 * (https://developer.android.com/about/versions/12/foreground-services) 644 */ 645 volatile boolean mFgsAllowOptOut = DEFAULT_FGS_ALLOW_OPT_OUT; 646 647 /* 648 * The extra delays we're putting to service restarts, based on current memory pressure. 649 */ 650 @GuardedBy("mService") 651 long[] mExtraServiceRestartDelayOnMemPressure = 652 DEFAULT_EXTRA_SERVICE_RESTART_DELAY_ON_MEM_PRESSURE; 653 654 /** 655 * Whether or not to enable the extra delays to service restarts on memory pressure. 656 */ 657 @GuardedBy("mService") 658 boolean mEnableExtraServiceRestartDelayOnMemPressure = 659 DEFAULT_ENABLE_EXTRA_SERVICE_RESTART_DELAY_ON_MEM_PRESSURE; 660 661 /** 662 * Whether to enable "component alias" experimental feature. This can only be enabled 663 * on userdebug or eng builds. 664 */ 665 volatile boolean mEnableComponentAlias = DEFAULT_ENABLE_COMPONENT_ALIAS; 666 667 /** 668 * Where or not to defer LOCKED_BOOT_COMPLETED and BOOT_COMPLETED broadcasts until the first 669 * time the process of the UID is started. 670 * Defined in {@link BroadcastConstants#DeferBootCompletedBroadcastType} 671 */ 672 @GuardedBy("mService") 673 volatile @BroadcastConstants.DeferBootCompletedBroadcastType int mDeferBootCompletedBroadcast = 674 DEFAULT_DEFER_BOOT_COMPLETED_BROADCAST; 675 676 /** 677 * How long the Context.startForegroundService() grace period is to get around to 678 * calling Service.startForeground() before we generate ANR. 679 */ 680 volatile int mServiceStartForegroundTimeoutMs = DEFAULT_SERVICE_START_FOREGROUND_TIMEOUT_MS; 681 682 /** 683 * How long from Service.startForeground() timed-out to when we generate ANR of the user app. 684 * This delay is after the timeout {@link #mServiceStartForegroundTimeoutMs}. 685 */ 686 volatile int mServiceStartForegroundAnrDelayMs = 687 DEFAULT_SERVICE_START_FOREGROUND_ANR_DELAY_MS; 688 689 /** 690 * How long the grace period is from starting an almost perceptible service to a successful 691 * binding before we stop considering it an almost perceptible service. 692 */ 693 volatile long mServiceBindAlmostPerceptibleTimeoutMs = 694 DEFAULT_SERVICE_BIND_ALMOST_PERCEPTIBLE_TIMEOUT_MS; 695 696 /** 697 * Defines component aliases. Format 698 * ComponentName ":" ComponentName ( "," ComponentName ":" ComponentName )* 699 */ 700 volatile String mComponentAliasOverrides = DEFAULT_COMPONENT_ALIAS_OVERRIDES; 701 702 private final ActivityManagerService mService; 703 private ContentResolver mResolver; 704 private final KeyValueListParser mParser = new KeyValueListParser(','); 705 706 private int mOverrideMaxCachedProcesses = -1; 707 private final int mCustomizedMaxCachedProcesses; 708 709 // The maximum number of cached processes we will keep around before killing them. 710 // NOTE: this constant is *only* a control to not let us go too crazy with 711 // keeping around processes on devices with large amounts of RAM. For devices that 712 // are tighter on RAM, the out of memory killer is responsible for killing background 713 // processes as RAM is needed, and we should *never* be relying on this limit to 714 // kill them. Also note that this limit only applies to cached background processes; 715 // we have no limit on the number of service, visible, foreground, or other such 716 // processes and the number of those processes does not count against the cached 717 // process limit. This will be initialized in the constructor. 718 public int CUR_MAX_CACHED_PROCESSES; 719 720 // The maximum number of empty app processes we will let sit around. This will be 721 // initialized in the constructor. 722 public int CUR_MAX_EMPTY_PROCESSES; 723 724 725 /** @see #mNoKillCachedProcessesUntilBootCompleted */ 726 private static final String KEY_NO_KILL_CACHED_PROCESSES_UNTIL_BOOT_COMPLETED = 727 "no_kill_cached_processes_until_boot_completed"; 728 729 /** @see #mNoKillCachedProcessesPostBootCompletedDurationMillis */ 730 private static final String KEY_NO_KILL_CACHED_PROCESSES_POST_BOOT_COMPLETED_DURATION_MILLIS = 731 "no_kill_cached_processes_post_boot_completed_duration_millis"; 732 733 /** @see #mNoKillCachedProcessesUntilBootCompleted */ 734 private static final boolean DEFAULT_NO_KILL_CACHED_PROCESSES_UNTIL_BOOT_COMPLETED = true; 735 736 /** @see #mNoKillCachedProcessesPostBootCompletedDurationMillis */ 737 private static final long 738 DEFAULT_NO_KILL_CACHED_PROCESSES_POST_BOOT_COMPLETED_DURATION_MILLIS = 600_000; 739 740 /** 741 * If true, do not kill excessive cached processes proactively, until user-0 is unlocked. 742 * @see #mNoKillCachedProcessesPostBootCompletedDurationMillis 743 */ 744 volatile boolean mNoKillCachedProcessesUntilBootCompleted = 745 DEFAULT_NO_KILL_CACHED_PROCESSES_UNTIL_BOOT_COMPLETED; 746 747 /** 748 * Do not kill excessive cached processes proactively, for this duration after each user is 749 * unlocked. 750 * Note we don't proactively kill extra cached processes after this. The next oomadjuster pass 751 * will naturally do it. 752 */ 753 volatile long mNoKillCachedProcessesPostBootCompletedDurationMillis = 754 DEFAULT_NO_KILL_CACHED_PROCESSES_POST_BOOT_COMPLETED_DURATION_MILLIS; 755 756 // The number of empty apps at which we don't consider it necessary to do 757 // memory trimming. 758 public int CUR_TRIM_EMPTY_PROCESSES = computeEmptyProcessLimit(MAX_CACHED_PROCESSES) / 2; 759 760 // The number of cached at which we don't consider it necessary to do 761 // memory trimming. 762 public int CUR_TRIM_CACHED_PROCESSES = 763 (MAX_CACHED_PROCESSES - computeEmptyProcessLimit(MAX_CACHED_PROCESSES)) / 3; 764 765 /** @see #mNoKillCachedProcessesUntilBootCompleted */ 766 private static final String KEY_MAX_EMPTY_TIME_MILLIS = 767 "max_empty_time_millis"; 768 769 private static final long DEFAULT_MAX_EMPTY_TIME_MILLIS = 30 * 60 * 1000; 770 771 volatile long mMaxEmptyTimeMillis = DEFAULT_MAX_EMPTY_TIME_MILLIS; 772 773 /** 774 * Packages that can't be killed even if it's requested to be killed on imperceptible. 775 */ 776 public ArraySet<String> IMPERCEPTIBLE_KILL_EXEMPT_PACKAGES = new ArraySet<String>(); 777 778 /** 779 * Proc State that can't be killed even if it's requested to be killed on imperceptible. 780 */ 781 public ArraySet<Integer> IMPERCEPTIBLE_KILL_EXEMPT_PROC_STATES = new ArraySet<Integer>(); 782 783 /** 784 * The threshold for the amount of PendingIntent for each UID, there will be 785 * warning logs if the number goes beyond this threshold. 786 */ 787 public int PENDINGINTENT_WARNING_THRESHOLD = DEFAULT_PENDINGINTENT_WARNING_THRESHOLD; 788 789 /** 790 * Component names of the services which will keep critical code path of the host warm 791 */ 792 public final ArraySet<ComponentName> KEEP_WARMING_SERVICES = new ArraySet<ComponentName>(); 793 794 /** 795 * Maximum number of phantom processes. 796 */ 797 public int MAX_PHANTOM_PROCESSES = DEFAULT_MAX_PHANTOM_PROCESSES; 798 799 private List<String> mDefaultImperceptibleKillExemptPackages; 800 private List<Integer> mDefaultImperceptibleKillExemptProcStates; 801 802 /** 803 * Indicates the maximum time spent waiting for the network rules to get updated. 804 */ 805 volatile long mNetworkAccessTimeoutMs = DEFAULT_NETWORK_ACCESS_TIMEOUT_MS; 806 807 @SuppressWarnings("unused") 808 private static final int OOMADJ_UPDATE_POLICY_SLOW = 0; 809 private static final int OOMADJ_UPDATE_POLICY_QUICK = 1; 810 private static final int DEFAULT_OOMADJ_UPDATE_POLICY = OOMADJ_UPDATE_POLICY_QUICK; 811 812 private static final String KEY_OOMADJ_UPDATE_POLICY = "oomadj_update_policy"; 813 814 // Indicate if the oom adjuster should take the quick path to update the oom adj scores, 815 // in which no futher actions will be performed if there are no significant adj/proc state 816 // changes for the specific process; otherwise, use the traditonal slow path which would 817 // keep updating all processes in the LRU list. 818 public boolean OOMADJ_UPDATE_QUICK = DEFAULT_OOMADJ_UPDATE_POLICY == OOMADJ_UPDATE_POLICY_QUICK; 819 820 private static final long MIN_AUTOMATIC_HEAP_DUMP_PSS_THRESHOLD_BYTES = 100 * 1024; // 100 KB 821 822 private final boolean mSystemServerAutomaticHeapDumpEnabled; 823 824 /** Package to report to when the memory usage exceeds the limit. */ 825 private final String mSystemServerAutomaticHeapDumpPackageName; 826 827 /** Byte limit for dump heap monitoring. */ 828 private long mSystemServerAutomaticHeapDumpPssThresholdBytes; 829 830 private static final Uri ACTIVITY_MANAGER_CONSTANTS_URI = Settings.Global.getUriFor( 831 Settings.Global.ACTIVITY_MANAGER_CONSTANTS); 832 833 private static final Uri ACTIVITY_STARTS_LOGGING_ENABLED_URI = Settings.Global.getUriFor( 834 Settings.Global.ACTIVITY_STARTS_LOGGING_ENABLED); 835 836 private static final Uri FOREGROUND_SERVICE_STARTS_LOGGING_ENABLED_URI = 837 Settings.Global.getUriFor( 838 Settings.Global.FOREGROUND_SERVICE_STARTS_LOGGING_ENABLED); 839 840 private static final Uri ENABLE_AUTOMATIC_SYSTEM_SERVER_HEAP_DUMPS_URI = 841 Settings.Global.getUriFor(Settings.Global.ENABLE_AUTOMATIC_SYSTEM_SERVER_HEAP_DUMPS); 842 843 /** 844 * The threshold to decide if a given association should be dumped into metrics. 845 */ 846 private static final long DEFAULT_MIN_ASSOC_LOG_DURATION = 5 * 60 * 1000; // 5 mins 847 848 private static final boolean DEFAULT_PROACTIVE_KILLS_ENABLED = false; 849 850 private static final float DEFAULT_LOW_SWAP_THRESHOLD_PERCENT = 0.10f; 851 852 private static final String KEY_MIN_ASSOC_LOG_DURATION = "min_assoc_log_duration"; 853 854 public static long MIN_ASSOC_LOG_DURATION = DEFAULT_MIN_ASSOC_LOG_DURATION; 855 856 private static final String KEY_BINDER_HEAVY_HITTER_WATCHER_ENABLED = 857 "binder_heavy_hitter_watcher_enabled"; 858 private static final String KEY_BINDER_HEAVY_HITTER_WATCHER_BATCHSIZE = 859 "binder_heavy_hitter_watcher_batchsize"; 860 private static final String KEY_BINDER_HEAVY_HITTER_WATCHER_THRESHOLD = 861 "binder_heavy_hitter_watcher_threshold"; 862 private static final String KEY_BINDER_HEAVY_HITTER_AUTO_SAMPLER_ENABLED = 863 "binder_heavy_hitter_auto_sampler_enabled"; 864 private static final String KEY_BINDER_HEAVY_HITTER_AUTO_SAMPLER_BATCHSIZE = 865 "binder_heavy_hitter_auto_sampler_batchsize"; 866 private static final String KEY_BINDER_HEAVY_HITTER_AUTO_SAMPLER_THRESHOLD = 867 "binder_heavy_hitter_auto_sampler_threshold"; 868 869 private final boolean mDefaultBinderHeavyHitterWatcherEnabled; 870 private final int mDefaultBinderHeavyHitterWatcherBatchSize; 871 private final float mDefaultBinderHeavyHitterWatcherThreshold; 872 private final boolean mDefaultBinderHeavyHitterAutoSamplerEnabled; 873 private final int mDefaultBinderHeavyHitterAutoSamplerBatchSize; 874 private final float mDefaultBinderHeavyHitterAutoSamplerThreshold; 875 876 public static boolean BINDER_HEAVY_HITTER_WATCHER_ENABLED; 877 public static int BINDER_HEAVY_HITTER_WATCHER_BATCHSIZE; 878 public static float BINDER_HEAVY_HITTER_WATCHER_THRESHOLD; 879 public static boolean BINDER_HEAVY_HITTER_AUTO_SAMPLER_ENABLED; 880 public static int BINDER_HEAVY_HITTER_AUTO_SAMPLER_BATCHSIZE; 881 public static float BINDER_HEAVY_HITTER_AUTO_SAMPLER_THRESHOLD; 882 public static boolean PROACTIVE_KILLS_ENABLED = DEFAULT_PROACTIVE_KILLS_ENABLED; 883 public static float LOW_SWAP_THRESHOLD_PERCENT = DEFAULT_LOW_SWAP_THRESHOLD_PERCENT; 884 885 private final OnPropertiesChangedListener mOnDeviceConfigChangedListener = 886 new OnPropertiesChangedListener() { 887 @Override 888 public void onPropertiesChanged(Properties properties) { 889 for (String name : properties.getKeyset()) { 890 if (name == null) { 891 return; 892 } 893 switch (name) { 894 case KEY_MAX_CACHED_PROCESSES: 895 updateMaxCachedProcesses(); 896 break; 897 case KEY_DEFAULT_BACKGROUND_ACTIVITY_STARTS_ENABLED: 898 updateBackgroundActivityStarts(); 899 break; 900 case KEY_DEFAULT_BACKGROUND_FGS_STARTS_RESTRICTION_ENABLED: 901 updateBackgroundFgsStartsRestriction(); 902 break; 903 case KEY_DEFAULT_FGS_STARTS_RESTRICTION_ENABLED: 904 updateFgsStartsRestriction(); 905 break; 906 case KEY_DEFAULT_FGS_STARTS_RESTRICTION_NOTIFICATION_ENABLED: 907 updateFgsStartsRestrictionNotification(); 908 break; 909 case KEY_DEFAULT_FGS_STARTS_RESTRICTION_CHECK_CALLER_TARGET_SDK: 910 updateFgsStartsRestrictionCheckCallerTargetSdk(); 911 break; 912 case KEY_DEFERRED_FGS_NOTIFICATIONS_ENABLED: 913 updateFgsNotificationDeferralEnable(); 914 break; 915 case KEY_DEFERRED_FGS_NOTIFICATIONS_API_GATED: 916 updateFgsNotificationDeferralApiGated(); 917 break; 918 case KEY_DEFERRED_FGS_NOTIFICATION_INTERVAL: 919 updateFgsNotificationDeferralInterval(); 920 break; 921 case KEY_DEFERRED_FGS_NOTIFICATION_EXCLUSION_TIME: 922 updateFgsNotificationDeferralExclusionTime(); 923 break; 924 case KEY_PUSH_MESSAGING_OVER_QUOTA_BEHAVIOR: 925 updatePushMessagingOverQuotaBehavior(); 926 break; 927 case KEY_OOMADJ_UPDATE_POLICY: 928 updateOomAdjUpdatePolicy(); 929 break; 930 case KEY_IMPERCEPTIBLE_KILL_EXEMPT_PACKAGES: 931 case KEY_IMPERCEPTIBLE_KILL_EXEMPT_PROC_STATES: 932 updateImperceptibleKillExemptions(); 933 break; 934 case KEY_FORCE_BACKGROUND_CHECK_ON_RESTRICTED_APPS: 935 updateForceRestrictedBackgroundCheck(); 936 break; 937 case KEY_MIN_ASSOC_LOG_DURATION: 938 updateMinAssocLogDuration(); 939 break; 940 case KEY_BINDER_HEAVY_HITTER_WATCHER_ENABLED: 941 case KEY_BINDER_HEAVY_HITTER_WATCHER_BATCHSIZE: 942 case KEY_BINDER_HEAVY_HITTER_WATCHER_THRESHOLD: 943 case KEY_BINDER_HEAVY_HITTER_AUTO_SAMPLER_ENABLED: 944 case KEY_BINDER_HEAVY_HITTER_AUTO_SAMPLER_BATCHSIZE: 945 case KEY_BINDER_HEAVY_HITTER_AUTO_SAMPLER_THRESHOLD: 946 updateBinderHeavyHitterWatcher(); 947 break; 948 case KEY_MAX_PHANTOM_PROCESSES: 949 updateMaxPhantomProcesses(); 950 break; 951 case KEY_BOOT_TIME_TEMP_ALLOWLIST_DURATION: 952 updateBootTimeTempAllowListDuration(); 953 break; 954 case KEY_FG_TO_BG_FGS_GRACE_DURATION: 955 updateFgToBgFgsGraceDuration(); 956 break; 957 case KEY_FGS_START_FOREGROUND_TIMEOUT: 958 updateFgsStartForegroundTimeout(); 959 break; 960 case KEY_FGS_ATOM_SAMPLE_RATE: 961 updateFgsAtomSamplePercent(); 962 break; 963 case KEY_FGS_START_ALLOWED_LOG_SAMPLE_RATE: 964 updateFgsStartAllowedLogSamplePercent(); 965 break; 966 case KEY_FGS_START_DENIED_LOG_SAMPLE_RATE: 967 updateFgsStartDeniedLogSamplePercent(); 968 break; 969 case KEY_KILL_BG_RESTRICTED_CACHED_IDLE: 970 updateKillBgRestrictedCachedIdle(); 971 break; 972 case KEY_KILL_BG_RESTRICTED_CACHED_IDLE_SETTLE_TIME: 973 updateKillBgRestrictedCachedIdleSettleTime(); 974 break; 975 case KEY_FGS_ALLOW_OPT_OUT: 976 updateFgsAllowOptOut(); 977 break; 978 case KEY_EXTRA_SERVICE_RESTART_DELAY_ON_MEM_PRESSURE: 979 updateExtraServiceRestartDelayOnMemPressure(); 980 break; 981 case KEY_ENABLE_EXTRA_SERVICE_RESTART_DELAY_ON_MEM_PRESSURE: 982 updateEnableExtraServiceRestartDelayOnMemPressure(); 983 break; 984 case KEY_PROCESS_KILL_TIMEOUT: 985 updateProcessKillTimeout(); 986 break; 987 case KEY_DEFER_BOOT_COMPLETED_BROADCAST: 988 updateDeferBootCompletedBroadcast(); 989 break; 990 case KEY_SERVICE_START_FOREGROUND_TIMEOUT_MS: 991 updateServiceStartForegroundTimeoutMs(); 992 break; 993 case KEY_SERVICE_START_FOREGROUND_ANR_DELAY_MS: 994 updateServiceStartForegroundAnrDealyMs(); 995 break; 996 case KEY_SERVICE_BIND_ALMOST_PERCEPTIBLE_TIMEOUT_MS: 997 updateServiceBindAlmostPerceptibleTimeoutMs(); 998 break; 999 case KEY_NO_KILL_CACHED_PROCESSES_UNTIL_BOOT_COMPLETED: 1000 updateNoKillCachedProcessesUntilBootCompleted(); 1001 break; 1002 case KEY_NO_KILL_CACHED_PROCESSES_POST_BOOT_COMPLETED_DURATION_MILLIS: 1003 updateNoKillCachedProcessesPostBootCompletedDurationMillis(); 1004 break; 1005 case KEY_MAX_EMPTY_TIME_MILLIS: 1006 updateMaxEmptyTimeMillis(); 1007 break; 1008 case KEY_NETWORK_ACCESS_TIMEOUT_MS: 1009 updateNetworkAccessTimeoutMs(); 1010 break; 1011 case KEY_PROACTIVE_KILLS_ENABLED: 1012 updateProactiveKillsEnabled(); 1013 break; 1014 case KEY_LOW_SWAP_THRESHOLD_PERCENT: 1015 updateLowSwapThresholdPercent(); 1016 break; 1017 default: 1018 break; 1019 } 1020 } 1021 } 1022 }; 1023 1024 private final OnPropertiesChangedListener mOnDeviceConfigChangedForComponentAliasListener = 1025 new OnPropertiesChangedListener() { 1026 @Override 1027 public void onPropertiesChanged(Properties properties) { 1028 for (String name : properties.getKeyset()) { 1029 if (name == null) { 1030 return; 1031 } 1032 switch (name) { 1033 case KEY_ENABLE_COMPONENT_ALIAS: 1034 case KEY_COMPONENT_ALIAS_OVERRIDES: 1035 updateComponentAliases(); 1036 break; 1037 default: 1038 break; 1039 } 1040 } 1041 } 1042 }; 1043 ActivityManagerConstants(Context context, ActivityManagerService service, Handler handler)1044 ActivityManagerConstants(Context context, ActivityManagerService service, Handler handler) { 1045 super(handler); 1046 mService = service; 1047 mSystemServerAutomaticHeapDumpEnabled = Build.IS_DEBUGGABLE 1048 && context.getResources().getBoolean( 1049 com.android.internal.R.bool.config_debugEnableAutomaticSystemServerHeapDumps); 1050 mSystemServerAutomaticHeapDumpPackageName = context.getPackageName(); 1051 mSystemServerAutomaticHeapDumpPssThresholdBytes = Math.max( 1052 MIN_AUTOMATIC_HEAP_DUMP_PSS_THRESHOLD_BYTES, 1053 context.getResources().getInteger( 1054 com.android.internal.R.integer.config_debugSystemServerPssThresholdBytes)); 1055 mDefaultImperceptibleKillExemptPackages = Arrays.asList( 1056 context.getResources().getStringArray( 1057 com.android.internal.R.array.config_defaultImperceptibleKillingExemptionPkgs)); 1058 mDefaultImperceptibleKillExemptProcStates = Arrays.stream( 1059 context.getResources().getIntArray( 1060 com.android.internal.R.array.config_defaultImperceptibleKillingExemptionProcStates)) 1061 .boxed().collect(Collectors.toList()); 1062 IMPERCEPTIBLE_KILL_EXEMPT_PACKAGES.addAll(mDefaultImperceptibleKillExemptPackages); 1063 IMPERCEPTIBLE_KILL_EXEMPT_PROC_STATES.addAll(mDefaultImperceptibleKillExemptProcStates); 1064 mDefaultBinderHeavyHitterWatcherEnabled = context.getResources().getBoolean( 1065 com.android.internal.R.bool.config_defaultBinderHeavyHitterWatcherEnabled); 1066 mDefaultBinderHeavyHitterWatcherBatchSize = context.getResources().getInteger( 1067 com.android.internal.R.integer.config_defaultBinderHeavyHitterWatcherBatchSize); 1068 mDefaultBinderHeavyHitterWatcherThreshold = context.getResources().getFloat( 1069 com.android.internal.R.dimen.config_defaultBinderHeavyHitterWatcherThreshold); 1070 mDefaultBinderHeavyHitterAutoSamplerEnabled = context.getResources().getBoolean( 1071 com.android.internal.R.bool.config_defaultBinderHeavyHitterAutoSamplerEnabled); 1072 mDefaultBinderHeavyHitterAutoSamplerBatchSize = context.getResources().getInteger( 1073 com.android.internal.R.integer.config_defaultBinderHeavyHitterAutoSamplerBatchSize); 1074 mDefaultBinderHeavyHitterAutoSamplerThreshold = context.getResources().getFloat( 1075 com.android.internal.R.dimen.config_defaultBinderHeavyHitterAutoSamplerThreshold); 1076 BINDER_HEAVY_HITTER_WATCHER_ENABLED = mDefaultBinderHeavyHitterWatcherEnabled; 1077 BINDER_HEAVY_HITTER_WATCHER_BATCHSIZE = mDefaultBinderHeavyHitterWatcherBatchSize; 1078 BINDER_HEAVY_HITTER_WATCHER_THRESHOLD = mDefaultBinderHeavyHitterWatcherThreshold; 1079 BINDER_HEAVY_HITTER_AUTO_SAMPLER_ENABLED = mDefaultBinderHeavyHitterAutoSamplerEnabled; 1080 BINDER_HEAVY_HITTER_AUTO_SAMPLER_BATCHSIZE = mDefaultBinderHeavyHitterAutoSamplerBatchSize; 1081 BINDER_HEAVY_HITTER_AUTO_SAMPLER_THRESHOLD = mDefaultBinderHeavyHitterAutoSamplerThreshold; 1082 service.scheduleUpdateBinderHeavyHitterWatcherConfig(); 1083 KEEP_WARMING_SERVICES.addAll(Arrays.stream( 1084 context.getResources().getStringArray( 1085 com.android.internal.R.array.config_keep_warming_services)) 1086 .map(ComponentName::unflattenFromString).collect(Collectors.toSet())); 1087 mCustomizedMaxCachedProcesses = context.getResources().getInteger( 1088 com.android.internal.R.integer.config_customizedMaxCachedProcesses); 1089 CUR_MAX_CACHED_PROCESSES = mCustomizedMaxCachedProcesses; 1090 CUR_MAX_EMPTY_PROCESSES = computeEmptyProcessLimit(CUR_MAX_CACHED_PROCESSES); 1091 } 1092 start(ContentResolver resolver)1093 public void start(ContentResolver resolver) { 1094 mResolver = resolver; 1095 mResolver.registerContentObserver(ACTIVITY_MANAGER_CONSTANTS_URI, false, this); 1096 mResolver.registerContentObserver(ACTIVITY_STARTS_LOGGING_ENABLED_URI, false, this); 1097 mResolver.registerContentObserver(FOREGROUND_SERVICE_STARTS_LOGGING_ENABLED_URI, 1098 false, this); 1099 if (mSystemServerAutomaticHeapDumpEnabled) { 1100 mResolver.registerContentObserver(ENABLE_AUTOMATIC_SYSTEM_SERVER_HEAP_DUMPS_URI, 1101 false, this); 1102 } 1103 updateConstants(); 1104 if (mSystemServerAutomaticHeapDumpEnabled) { 1105 updateEnableAutomaticSystemServerHeapDumps(); 1106 } 1107 DeviceConfig.addOnPropertiesChangedListener(DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, 1108 ActivityThread.currentApplication().getMainExecutor(), 1109 mOnDeviceConfigChangedListener); 1110 DeviceConfig.addOnPropertiesChangedListener( 1111 DeviceConfig.NAMESPACE_ACTIVITY_MANAGER_COMPONENT_ALIAS, 1112 ActivityThread.currentApplication().getMainExecutor(), 1113 mOnDeviceConfigChangedForComponentAliasListener); 1114 loadDeviceConfigConstants(); 1115 // The following read from Settings. 1116 updateActivityStartsLoggingEnabled(); 1117 updateForegroundServiceStartsLoggingEnabled(); 1118 } 1119 loadDeviceConfigConstants()1120 private void loadDeviceConfigConstants() { 1121 mOnDeviceConfigChangedListener.onPropertiesChanged( 1122 DeviceConfig.getProperties(DeviceConfig.NAMESPACE_ACTIVITY_MANAGER)); 1123 mOnDeviceConfigChangedForComponentAliasListener.onPropertiesChanged( 1124 DeviceConfig.getProperties( 1125 DeviceConfig.NAMESPACE_ACTIVITY_MANAGER_COMPONENT_ALIAS)); 1126 } 1127 setOverrideMaxCachedProcesses(int value)1128 public void setOverrideMaxCachedProcesses(int value) { 1129 mOverrideMaxCachedProcesses = value; 1130 updateMaxCachedProcesses(); 1131 } 1132 getOverrideMaxCachedProcesses()1133 public int getOverrideMaxCachedProcesses() { 1134 return mOverrideMaxCachedProcesses; 1135 } 1136 computeEmptyProcessLimit(int totalProcessLimit)1137 public static int computeEmptyProcessLimit(int totalProcessLimit) { 1138 return totalProcessLimit/2; 1139 } 1140 1141 @Override onChange(boolean selfChange, Uri uri)1142 public void onChange(boolean selfChange, Uri uri) { 1143 if (uri == null) return; 1144 if (ACTIVITY_MANAGER_CONSTANTS_URI.equals(uri)) { 1145 updateConstants(); 1146 } else if (ACTIVITY_STARTS_LOGGING_ENABLED_URI.equals(uri)) { 1147 updateActivityStartsLoggingEnabled(); 1148 } else if (FOREGROUND_SERVICE_STARTS_LOGGING_ENABLED_URI.equals(uri)) { 1149 updateForegroundServiceStartsLoggingEnabled(); 1150 } else if (ENABLE_AUTOMATIC_SYSTEM_SERVER_HEAP_DUMPS_URI.equals(uri)) { 1151 updateEnableAutomaticSystemServerHeapDumps(); 1152 } 1153 } 1154 updateConstants()1155 private void updateConstants() { 1156 final String setting = Settings.Global.getString(mResolver, 1157 Settings.Global.ACTIVITY_MANAGER_CONSTANTS); 1158 synchronized (mService) { 1159 try { 1160 mParser.setString(setting); 1161 } catch (IllegalArgumentException e) { 1162 // Failed to parse the settings string, log this and move on 1163 // with defaults. 1164 Slog.e("ActivityManagerConstants", "Bad activity manager config settings", e); 1165 } 1166 final long currentPowerCheckInterval = POWER_CHECK_INTERVAL; 1167 1168 BACKGROUND_SETTLE_TIME = mParser.getLong(KEY_BACKGROUND_SETTLE_TIME, 1169 DEFAULT_BACKGROUND_SETTLE_TIME); 1170 FGSERVICE_MIN_SHOWN_TIME = mParser.getLong(KEY_FGSERVICE_MIN_SHOWN_TIME, 1171 DEFAULT_FGSERVICE_MIN_SHOWN_TIME); 1172 FGSERVICE_MIN_REPORT_TIME = mParser.getLong(KEY_FGSERVICE_MIN_REPORT_TIME, 1173 DEFAULT_FGSERVICE_MIN_REPORT_TIME); 1174 FGSERVICE_SCREEN_ON_BEFORE_TIME = mParser.getLong(KEY_FGSERVICE_SCREEN_ON_BEFORE_TIME, 1175 DEFAULT_FGSERVICE_SCREEN_ON_BEFORE_TIME); 1176 FGSERVICE_SCREEN_ON_AFTER_TIME = mParser.getLong(KEY_FGSERVICE_SCREEN_ON_AFTER_TIME, 1177 DEFAULT_FGSERVICE_SCREEN_ON_AFTER_TIME); 1178 CONTENT_PROVIDER_RETAIN_TIME = mParser.getLong(KEY_CONTENT_PROVIDER_RETAIN_TIME, 1179 DEFAULT_CONTENT_PROVIDER_RETAIN_TIME); 1180 GC_TIMEOUT = mParser.getLong(KEY_GC_TIMEOUT, 1181 DEFAULT_GC_TIMEOUT); 1182 GC_MIN_INTERVAL = mParser.getLong(KEY_GC_MIN_INTERVAL, 1183 DEFAULT_GC_MIN_INTERVAL); 1184 FULL_PSS_MIN_INTERVAL = mParser.getLong(KEY_FULL_PSS_MIN_INTERVAL, 1185 DEFAULT_FULL_PSS_MIN_INTERVAL); 1186 FULL_PSS_LOWERED_INTERVAL = mParser.getLong(KEY_FULL_PSS_LOWERED_INTERVAL, 1187 DEFAULT_FULL_PSS_LOWERED_INTERVAL); 1188 POWER_CHECK_INTERVAL = mParser.getLong(KEY_POWER_CHECK_INTERVAL, 1189 DEFAULT_POWER_CHECK_INTERVAL); 1190 POWER_CHECK_MAX_CPU_1 = mParser.getInt(KEY_POWER_CHECK_MAX_CPU_1, 1191 DEFAULT_POWER_CHECK_MAX_CPU_1); 1192 POWER_CHECK_MAX_CPU_2 = mParser.getInt(KEY_POWER_CHECK_MAX_CPU_2, 1193 DEFAULT_POWER_CHECK_MAX_CPU_2); 1194 POWER_CHECK_MAX_CPU_3 = mParser.getInt(KEY_POWER_CHECK_MAX_CPU_3, 1195 DEFAULT_POWER_CHECK_MAX_CPU_3); 1196 POWER_CHECK_MAX_CPU_4 = mParser.getInt(KEY_POWER_CHECK_MAX_CPU_4, 1197 DEFAULT_POWER_CHECK_MAX_CPU_4); 1198 SERVICE_USAGE_INTERACTION_TIME_PRE_S = mParser.getLong( 1199 KEY_SERVICE_USAGE_INTERACTION_TIME_PRE_S, 1200 DEFAULT_SERVICE_USAGE_INTERACTION_TIME_PRE_S); 1201 SERVICE_USAGE_INTERACTION_TIME_POST_S = mParser.getLong( 1202 KEY_SERVICE_USAGE_INTERACTION_TIME_POST_S, 1203 DEFAULT_SERVICE_USAGE_INTERACTION_TIME_POST_S); 1204 USAGE_STATS_INTERACTION_INTERVAL_PRE_S = mParser.getLong( 1205 KEY_USAGE_STATS_INTERACTION_INTERVAL_PRE_S, 1206 DEFAULT_USAGE_STATS_INTERACTION_INTERVAL_PRE_S); 1207 USAGE_STATS_INTERACTION_INTERVAL_POST_S = mParser.getLong( 1208 KEY_USAGE_STATS_INTERACTION_INTERVAL_POST_S, 1209 DEFAULT_USAGE_STATS_INTERACTION_INTERVAL_POST_S); 1210 SERVICE_RESTART_DURATION = mParser.getLong(KEY_SERVICE_RESTART_DURATION, 1211 DEFAULT_SERVICE_RESTART_DURATION); 1212 SERVICE_RESET_RUN_DURATION = mParser.getLong(KEY_SERVICE_RESET_RUN_DURATION, 1213 DEFAULT_SERVICE_RESET_RUN_DURATION); 1214 SERVICE_RESTART_DURATION_FACTOR = mParser.getInt(KEY_SERVICE_RESTART_DURATION_FACTOR, 1215 DEFAULT_SERVICE_RESTART_DURATION_FACTOR); 1216 SERVICE_MIN_RESTART_TIME_BETWEEN = mParser.getLong(KEY_SERVICE_MIN_RESTART_TIME_BETWEEN, 1217 DEFAULT_SERVICE_MIN_RESTART_TIME_BETWEEN); 1218 MAX_SERVICE_INACTIVITY = mParser.getLong(KEY_MAX_SERVICE_INACTIVITY, 1219 DEFAULT_MAX_SERVICE_INACTIVITY); 1220 BG_START_TIMEOUT = mParser.getLong(KEY_BG_START_TIMEOUT, 1221 DEFAULT_BG_START_TIMEOUT); 1222 SERVICE_BG_ACTIVITY_START_TIMEOUT = mParser.getLong( 1223 KEY_SERVICE_BG_ACTIVITY_START_TIMEOUT, 1224 DEFAULT_SERVICE_BG_ACTIVITY_START_TIMEOUT); 1225 BOUND_SERVICE_CRASH_RESTART_DURATION = mParser.getLong( 1226 KEY_BOUND_SERVICE_CRASH_RESTART_DURATION, 1227 DEFAULT_BOUND_SERVICE_CRASH_RESTART_DURATION); 1228 BOUND_SERVICE_MAX_CRASH_RETRY = mParser.getInt(KEY_BOUND_SERVICE_CRASH_MAX_RETRY, 1229 DEFAULT_BOUND_SERVICE_CRASH_MAX_RETRY); 1230 FLAG_PROCESS_START_ASYNC = mParser.getBoolean(KEY_PROCESS_START_ASYNC, 1231 DEFAULT_PROCESS_START_ASYNC); 1232 MEMORY_INFO_THROTTLE_TIME = mParser.getLong(KEY_MEMORY_INFO_THROTTLE_TIME, 1233 DEFAULT_MEMORY_INFO_THROTTLE_TIME); 1234 TOP_TO_FGS_GRACE_DURATION = mParser.getDurationMillis(KEY_TOP_TO_FGS_GRACE_DURATION, 1235 DEFAULT_TOP_TO_FGS_GRACE_DURATION); 1236 TOP_TO_ALMOST_PERCEPTIBLE_GRACE_DURATION = mParser.getDurationMillis( 1237 KEY_TOP_TO_ALMOST_PERCEPTIBLE_GRACE_DURATION, 1238 DEFAULT_TOP_TO_ALMOST_PERCEPTIBLE_GRACE_DURATION); 1239 MIN_CRASH_INTERVAL = mParser.getInt(KEY_MIN_CRASH_INTERVAL, 1240 DEFAULT_MIN_CRASH_INTERVAL); 1241 PENDINGINTENT_WARNING_THRESHOLD = mParser.getInt(KEY_PENDINGINTENT_WARNING_THRESHOLD, 1242 DEFAULT_PENDINGINTENT_WARNING_THRESHOLD); 1243 PROCESS_CRASH_COUNT_RESET_INTERVAL = mParser.getInt( 1244 KEY_PROCESS_CRASH_COUNT_RESET_INTERVAL, 1245 DEFAULT_PROCESS_CRASH_COUNT_RESET_INTERVAL); 1246 PROCESS_CRASH_COUNT_LIMIT = mParser.getInt(KEY_PROCESS_CRASH_COUNT_LIMIT, 1247 DEFAULT_PROCESS_CRASH_COUNT_LIMIT); 1248 1249 if (POWER_CHECK_INTERVAL != currentPowerCheckInterval) { 1250 mService.mHandler.removeMessages( 1251 ActivityManagerService.CHECK_EXCESSIVE_POWER_USE_MSG); 1252 final Message msg = mService.mHandler.obtainMessage( 1253 ActivityManagerService.CHECK_EXCESSIVE_POWER_USE_MSG); 1254 mService.mHandler.sendMessageDelayed(msg, POWER_CHECK_INTERVAL); 1255 } 1256 // For new flags that are intended for server-side experiments, please use the new 1257 // DeviceConfig package. 1258 } 1259 } 1260 updateActivityStartsLoggingEnabled()1261 private void updateActivityStartsLoggingEnabled() { 1262 mFlagActivityStartsLoggingEnabled = Settings.Global.getInt(mResolver, 1263 Settings.Global.ACTIVITY_STARTS_LOGGING_ENABLED, 1) == 1; 1264 } 1265 updateBackgroundActivityStarts()1266 private void updateBackgroundActivityStarts() { 1267 mFlagBackgroundActivityStartsEnabled = DeviceConfig.getBoolean( 1268 DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, 1269 KEY_DEFAULT_BACKGROUND_ACTIVITY_STARTS_ENABLED, 1270 /*defaultValue*/ false); 1271 } 1272 updateForegroundServiceStartsLoggingEnabled()1273 private void updateForegroundServiceStartsLoggingEnabled() { 1274 mFlagForegroundServiceStartsLoggingEnabled = Settings.Global.getInt(mResolver, 1275 Settings.Global.FOREGROUND_SERVICE_STARTS_LOGGING_ENABLED, 1) == 1; 1276 } 1277 updateBackgroundFgsStartsRestriction()1278 private void updateBackgroundFgsStartsRestriction() { 1279 mFlagBackgroundFgsStartRestrictionEnabled = DeviceConfig.getBoolean( 1280 DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, 1281 KEY_DEFAULT_BACKGROUND_FGS_STARTS_RESTRICTION_ENABLED, 1282 /*defaultValue*/ true); 1283 } 1284 updateFgsStartsRestriction()1285 private void updateFgsStartsRestriction() { 1286 mFlagFgsStartRestrictionEnabled = DeviceConfig.getBoolean( 1287 DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, 1288 KEY_DEFAULT_FGS_STARTS_RESTRICTION_ENABLED, 1289 /*defaultValue*/ true); 1290 } 1291 updateFgsStartsRestrictionNotification()1292 private void updateFgsStartsRestrictionNotification() { 1293 mFgsStartRestrictionNotificationEnabled = DeviceConfig.getBoolean( 1294 DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, 1295 KEY_DEFAULT_FGS_STARTS_RESTRICTION_NOTIFICATION_ENABLED, 1296 /*defaultValue*/ false); 1297 } 1298 updateFgsStartsRestrictionCheckCallerTargetSdk()1299 private void updateFgsStartsRestrictionCheckCallerTargetSdk() { 1300 mFgsStartRestrictionCheckCallerTargetSdk = DeviceConfig.getBoolean( 1301 DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, 1302 KEY_DEFAULT_FGS_STARTS_RESTRICTION_CHECK_CALLER_TARGET_SDK, 1303 /*defaultValue*/ true); 1304 } 1305 updateFgsNotificationDeferralEnable()1306 private void updateFgsNotificationDeferralEnable() { 1307 mFlagFgsNotificationDeferralEnabled = DeviceConfig.getBoolean( 1308 DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, 1309 KEY_DEFERRED_FGS_NOTIFICATIONS_ENABLED, 1310 /*default value*/ true); 1311 } 1312 updateFgsNotificationDeferralApiGated()1313 private void updateFgsNotificationDeferralApiGated() { 1314 mFlagFgsNotificationDeferralApiGated = DeviceConfig.getBoolean( 1315 DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, 1316 KEY_DEFERRED_FGS_NOTIFICATIONS_API_GATED, 1317 /*default value*/ false); 1318 } 1319 updateFgsNotificationDeferralInterval()1320 private void updateFgsNotificationDeferralInterval() { 1321 mFgsNotificationDeferralInterval = DeviceConfig.getLong( 1322 DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, 1323 KEY_DEFERRED_FGS_NOTIFICATION_INTERVAL, 1324 /*default value*/ 10_000L); 1325 } 1326 updateFgsNotificationDeferralExclusionTime()1327 private void updateFgsNotificationDeferralExclusionTime() { 1328 mFgsNotificationDeferralExclusionTime = DeviceConfig.getLong( 1329 DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, 1330 KEY_DEFERRED_FGS_NOTIFICATION_EXCLUSION_TIME, 1331 /*default value*/ 2 * 60 * 1000L); 1332 } 1333 updatePushMessagingOverQuotaBehavior()1334 private void updatePushMessagingOverQuotaBehavior() { 1335 mPushMessagingOverQuotaBehavior = DeviceConfig.getInt( 1336 DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, 1337 KEY_PUSH_MESSAGING_OVER_QUOTA_BEHAVIOR, 1338 DEFAULT_PUSH_MESSAGING_OVER_QUOTA_BEHAVIOR); 1339 if (mPushMessagingOverQuotaBehavior < TEMPORARY_ALLOW_LIST_TYPE_NONE 1340 || mPushMessagingOverQuotaBehavior 1341 > TEMPORARY_ALLOW_LIST_TYPE_FOREGROUND_SERVICE_NOT_ALLOWED) { 1342 mPushMessagingOverQuotaBehavior = 1343 DEFAULT_PUSH_MESSAGING_OVER_QUOTA_BEHAVIOR; 1344 } 1345 } 1346 updateOomAdjUpdatePolicy()1347 private void updateOomAdjUpdatePolicy() { 1348 OOMADJ_UPDATE_QUICK = DeviceConfig.getInt( 1349 DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, 1350 KEY_OOMADJ_UPDATE_POLICY, 1351 /* defaultValue */ DEFAULT_OOMADJ_UPDATE_POLICY) 1352 == OOMADJ_UPDATE_POLICY_QUICK; 1353 } 1354 updateForceRestrictedBackgroundCheck()1355 private void updateForceRestrictedBackgroundCheck() { 1356 FORCE_BACKGROUND_CHECK_ON_RESTRICTED_APPS = DeviceConfig.getBoolean( 1357 DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, 1358 KEY_FORCE_BACKGROUND_CHECK_ON_RESTRICTED_APPS, 1359 DEFAULT_FORCE_BACKGROUND_CHECK_ON_RESTRICTED_APPS); 1360 } 1361 updateBootTimeTempAllowListDuration()1362 private void updateBootTimeTempAllowListDuration() { 1363 mBootTimeTempAllowlistDuration = DeviceConfig.getLong( 1364 DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, 1365 KEY_BOOT_TIME_TEMP_ALLOWLIST_DURATION, 1366 DEFAULT_BOOT_TIME_TEMP_ALLOWLIST_DURATION); 1367 } 1368 updateFgToBgFgsGraceDuration()1369 private void updateFgToBgFgsGraceDuration() { 1370 mFgToBgFgsGraceDuration = DeviceConfig.getLong( 1371 DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, 1372 KEY_FG_TO_BG_FGS_GRACE_DURATION, 1373 DEFAULT_FG_TO_BG_FGS_GRACE_DURATION); 1374 } 1375 updateFgsStartForegroundTimeout()1376 private void updateFgsStartForegroundTimeout() { 1377 mFgsStartForegroundTimeoutMs = DeviceConfig.getLong( 1378 DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, 1379 KEY_FGS_START_FOREGROUND_TIMEOUT, 1380 DEFAULT_FGS_START_FOREGROUND_TIMEOUT_MS); 1381 } 1382 updateFgsAtomSamplePercent()1383 private void updateFgsAtomSamplePercent() { 1384 mFgsAtomSampleRate = DeviceConfig.getFloat( 1385 DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, 1386 KEY_FGS_ATOM_SAMPLE_RATE, 1387 DEFAULT_FGS_ATOM_SAMPLE_RATE); 1388 } 1389 updateFgsStartAllowedLogSamplePercent()1390 private void updateFgsStartAllowedLogSamplePercent() { 1391 mFgsStartAllowedLogSampleRate = DeviceConfig.getFloat( 1392 DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, 1393 KEY_FGS_START_ALLOWED_LOG_SAMPLE_RATE, 1394 DEFAULT_FGS_START_ALLOWED_LOG_SAMPLE_RATE); 1395 } 1396 updateFgsStartDeniedLogSamplePercent()1397 private void updateFgsStartDeniedLogSamplePercent() { 1398 mFgsStartDeniedLogSampleRate = DeviceConfig.getFloat( 1399 DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, 1400 KEY_FGS_START_DENIED_LOG_SAMPLE_RATE, 1401 DEFAULT_FGS_START_DENIED_LOG_SAMPLE_RATE); 1402 } 1403 updateKillBgRestrictedCachedIdle()1404 private void updateKillBgRestrictedCachedIdle() { 1405 mKillBgRestrictedAndCachedIdle = DeviceConfig.getBoolean( 1406 DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, 1407 KEY_KILL_BG_RESTRICTED_CACHED_IDLE, 1408 DEFAULT_KILL_BG_RESTRICTED_CACHED_IDLE); 1409 } 1410 updateKillBgRestrictedCachedIdleSettleTime()1411 private void updateKillBgRestrictedCachedIdleSettleTime() { 1412 final long currentSettleTime = mKillBgRestrictedAndCachedIdleSettleTimeMs; 1413 mKillBgRestrictedAndCachedIdleSettleTimeMs = DeviceConfig.getLong( 1414 DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, 1415 KEY_KILL_BG_RESTRICTED_CACHED_IDLE_SETTLE_TIME, 1416 DEFAULT_KILL_BG_RESTRICTED_CACHED_IDLE_SETTLE_TIME_MS); 1417 if (mKillBgRestrictedAndCachedIdleSettleTimeMs != currentSettleTime) { 1418 mService.mHandler.removeMessages( 1419 ActivityManagerService.IDLE_UIDS_MSG); 1420 mService.mHandler.sendEmptyMessageDelayed( 1421 ActivityManagerService.IDLE_UIDS_MSG, 1422 mKillBgRestrictedAndCachedIdleSettleTimeMs); 1423 } 1424 } 1425 updateFgsAllowOptOut()1426 private void updateFgsAllowOptOut() { 1427 mFgsAllowOptOut = DeviceConfig.getBoolean( 1428 DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, 1429 KEY_FGS_ALLOW_OPT_OUT, 1430 DEFAULT_FGS_ALLOW_OPT_OUT); 1431 } 1432 updateExtraServiceRestartDelayOnMemPressure()1433 private void updateExtraServiceRestartDelayOnMemPressure() { 1434 synchronized (mService) { 1435 final int memFactor = mService.mAppProfiler.getLastMemoryLevelLocked(); 1436 final long[] prevDelays = mExtraServiceRestartDelayOnMemPressure; 1437 mExtraServiceRestartDelayOnMemPressure = parseLongArray( 1438 KEY_EXTRA_SERVICE_RESTART_DELAY_ON_MEM_PRESSURE, 1439 DEFAULT_EXTRA_SERVICE_RESTART_DELAY_ON_MEM_PRESSURE); 1440 mService.mServices.performRescheduleServiceRestartOnMemoryPressureLocked( 1441 mExtraServiceRestartDelayOnMemPressure[memFactor], 1442 prevDelays[memFactor], "config", SystemClock.uptimeMillis()); 1443 } 1444 } 1445 updateEnableExtraServiceRestartDelayOnMemPressure()1446 private void updateEnableExtraServiceRestartDelayOnMemPressure() { 1447 synchronized (mService) { 1448 final boolean prevEnabled = mEnableExtraServiceRestartDelayOnMemPressure; 1449 mEnableExtraServiceRestartDelayOnMemPressure = DeviceConfig.getBoolean( 1450 DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, 1451 KEY_ENABLE_EXTRA_SERVICE_RESTART_DELAY_ON_MEM_PRESSURE, 1452 DEFAULT_ENABLE_EXTRA_SERVICE_RESTART_DELAY_ON_MEM_PRESSURE); 1453 mService.mServices.rescheduleServiceRestartOnMemoryPressureIfNeededLocked( 1454 prevEnabled, mEnableExtraServiceRestartDelayOnMemPressure, 1455 SystemClock.uptimeMillis()); 1456 } 1457 } 1458 updateDeferBootCompletedBroadcast()1459 private void updateDeferBootCompletedBroadcast() { 1460 mDeferBootCompletedBroadcast = DeviceConfig.getInt( 1461 DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, 1462 KEY_DEFER_BOOT_COMPLETED_BROADCAST, 1463 DEFAULT_DEFER_BOOT_COMPLETED_BROADCAST); 1464 } 1465 updateNoKillCachedProcessesUntilBootCompleted()1466 private void updateNoKillCachedProcessesUntilBootCompleted() { 1467 mNoKillCachedProcessesUntilBootCompleted = DeviceConfig.getBoolean( 1468 DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, 1469 KEY_NO_KILL_CACHED_PROCESSES_UNTIL_BOOT_COMPLETED, 1470 DEFAULT_NO_KILL_CACHED_PROCESSES_UNTIL_BOOT_COMPLETED); 1471 } 1472 updateNoKillCachedProcessesPostBootCompletedDurationMillis()1473 private void updateNoKillCachedProcessesPostBootCompletedDurationMillis() { 1474 mNoKillCachedProcessesPostBootCompletedDurationMillis = DeviceConfig.getLong( 1475 DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, 1476 KEY_NO_KILL_CACHED_PROCESSES_POST_BOOT_COMPLETED_DURATION_MILLIS, 1477 DEFAULT_NO_KILL_CACHED_PROCESSES_POST_BOOT_COMPLETED_DURATION_MILLIS); 1478 } 1479 updateMaxEmptyTimeMillis()1480 private void updateMaxEmptyTimeMillis() { 1481 mMaxEmptyTimeMillis = DeviceConfig.getLong( 1482 DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, 1483 KEY_MAX_EMPTY_TIME_MILLIS, 1484 DEFAULT_MAX_EMPTY_TIME_MILLIS); 1485 } 1486 updateNetworkAccessTimeoutMs()1487 private void updateNetworkAccessTimeoutMs() { 1488 mNetworkAccessTimeoutMs = DeviceConfig.getLong( 1489 DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, 1490 KEY_NETWORK_ACCESS_TIMEOUT_MS, 1491 DEFAULT_NETWORK_ACCESS_TIMEOUT_MS); 1492 } 1493 updateServiceStartForegroundTimeoutMs()1494 private void updateServiceStartForegroundTimeoutMs() { 1495 mServiceStartForegroundTimeoutMs = DeviceConfig.getInt( 1496 DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, 1497 KEY_SERVICE_START_FOREGROUND_TIMEOUT_MS, 1498 DEFAULT_SERVICE_START_FOREGROUND_TIMEOUT_MS); 1499 } 1500 updateServiceStartForegroundAnrDealyMs()1501 private void updateServiceStartForegroundAnrDealyMs() { 1502 mServiceStartForegroundAnrDelayMs = DeviceConfig.getInt( 1503 DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, 1504 KEY_SERVICE_START_FOREGROUND_ANR_DELAY_MS, 1505 DEFAULT_SERVICE_START_FOREGROUND_ANR_DELAY_MS); 1506 } 1507 updateServiceBindAlmostPerceptibleTimeoutMs()1508 private void updateServiceBindAlmostPerceptibleTimeoutMs() { 1509 mServiceBindAlmostPerceptibleTimeoutMs = DeviceConfig.getLong( 1510 DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, 1511 KEY_SERVICE_BIND_ALMOST_PERCEPTIBLE_TIMEOUT_MS, 1512 DEFAULT_SERVICE_BIND_ALMOST_PERCEPTIBLE_TIMEOUT_MS); 1513 } 1514 1515 parseLongArray(@onNull String key, @NonNull long[] def)1516 private long[] parseLongArray(@NonNull String key, @NonNull long[] def) { 1517 final String val = DeviceConfig.getString(DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, 1518 key, null); 1519 if (!TextUtils.isEmpty(val)) { 1520 final String[] ss = val.split(","); 1521 if (ss.length == def.length) { 1522 final long[] tmp = new long[ss.length]; 1523 try { 1524 for (int i = 0; i < ss.length; i++) { 1525 tmp[i] = Long.parseLong(ss[i]); 1526 } 1527 return tmp; 1528 } catch (NumberFormatException e) { 1529 } 1530 } 1531 } 1532 return def; 1533 } 1534 updateComponentAliases()1535 private void updateComponentAliases() { 1536 mEnableComponentAlias = DeviceConfig.getBoolean( 1537 DeviceConfig.NAMESPACE_ACTIVITY_MANAGER_COMPONENT_ALIAS, 1538 KEY_ENABLE_COMPONENT_ALIAS, 1539 DEFAULT_ENABLE_COMPONENT_ALIAS); 1540 mComponentAliasOverrides = DeviceConfig.getString( 1541 DeviceConfig.NAMESPACE_ACTIVITY_MANAGER_COMPONENT_ALIAS, 1542 KEY_COMPONENT_ALIAS_OVERRIDES, 1543 DEFAULT_COMPONENT_ALIAS_OVERRIDES); 1544 mService.mComponentAliasResolver.update(mEnableComponentAlias, mComponentAliasOverrides); 1545 } 1546 updateProcessKillTimeout()1547 private void updateProcessKillTimeout() { 1548 mProcessKillTimeoutMs = DeviceConfig.getLong( 1549 DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, 1550 KEY_PROCESS_KILL_TIMEOUT, 1551 DEFAULT_PROCESS_KILL_TIMEOUT_MS); 1552 } 1553 updateImperceptibleKillExemptions()1554 private void updateImperceptibleKillExemptions() { 1555 IMPERCEPTIBLE_KILL_EXEMPT_PACKAGES.clear(); 1556 IMPERCEPTIBLE_KILL_EXEMPT_PACKAGES.addAll(mDefaultImperceptibleKillExemptPackages); 1557 String val = DeviceConfig.getString(DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, 1558 KEY_IMPERCEPTIBLE_KILL_EXEMPT_PACKAGES, null); 1559 if (!TextUtils.isEmpty(val)) { 1560 IMPERCEPTIBLE_KILL_EXEMPT_PACKAGES.addAll(Arrays.asList(val.split(","))); 1561 } 1562 1563 IMPERCEPTIBLE_KILL_EXEMPT_PROC_STATES.clear(); 1564 IMPERCEPTIBLE_KILL_EXEMPT_PROC_STATES.addAll(mDefaultImperceptibleKillExemptProcStates); 1565 val = DeviceConfig.getString(DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, 1566 KEY_IMPERCEPTIBLE_KILL_EXEMPT_PROC_STATES, null); 1567 if (!TextUtils.isEmpty(val)) { 1568 Arrays.asList(val.split(",")).stream().forEach((v) -> { 1569 try { 1570 IMPERCEPTIBLE_KILL_EXEMPT_PROC_STATES.add(Integer.parseInt(v)); 1571 } catch (NumberFormatException e) { 1572 } 1573 }); 1574 } 1575 } 1576 updateEnableAutomaticSystemServerHeapDumps()1577 private void updateEnableAutomaticSystemServerHeapDumps() { 1578 if (!mSystemServerAutomaticHeapDumpEnabled) { 1579 Slog.wtf(TAG, 1580 "updateEnableAutomaticSystemServerHeapDumps called when leak detection " 1581 + "disabled"); 1582 return; 1583 } 1584 // Monitoring is on by default, so if the setting hasn't been set by the user, 1585 // monitoring should be on. 1586 final boolean enabled = Settings.Global.getInt(mResolver, 1587 Settings.Global.ENABLE_AUTOMATIC_SYSTEM_SERVER_HEAP_DUMPS, 1) == 1; 1588 1589 // Setting the threshold to 0 stops the checking. 1590 final long threshold = enabled ? mSystemServerAutomaticHeapDumpPssThresholdBytes : 0; 1591 mService.setDumpHeapDebugLimit(null, 0, threshold, 1592 mSystemServerAutomaticHeapDumpPackageName); 1593 } 1594 updateMaxCachedProcesses()1595 private void updateMaxCachedProcesses() { 1596 String maxCachedProcessesFlag = DeviceConfig.getProperty( 1597 DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, KEY_MAX_CACHED_PROCESSES); 1598 try { 1599 CUR_MAX_CACHED_PROCESSES = mOverrideMaxCachedProcesses < 0 1600 ? (TextUtils.isEmpty(maxCachedProcessesFlag) 1601 ? mCustomizedMaxCachedProcesses : Integer.parseInt(maxCachedProcessesFlag)) 1602 : mOverrideMaxCachedProcesses; 1603 } catch (NumberFormatException e) { 1604 // Bad flag value from Phenotype, revert to default. 1605 Slog.e(TAG, 1606 "Unable to parse flag for max_cached_processes: " + maxCachedProcessesFlag, e); 1607 CUR_MAX_CACHED_PROCESSES = mCustomizedMaxCachedProcesses; 1608 } 1609 CUR_MAX_EMPTY_PROCESSES = computeEmptyProcessLimit(CUR_MAX_CACHED_PROCESSES); 1610 1611 // Note the trim levels do NOT depend on the override process limit, we want 1612 // to consider the same level the point where we do trimming regardless of any 1613 // additional enforced limit. 1614 final int rawMaxEmptyProcesses = computeEmptyProcessLimit(MAX_CACHED_PROCESSES); 1615 CUR_TRIM_EMPTY_PROCESSES = rawMaxEmptyProcesses/2; 1616 CUR_TRIM_CACHED_PROCESSES = (MAX_CACHED_PROCESSES-rawMaxEmptyProcesses)/3; 1617 } 1618 1619 private void updateProactiveKillsEnabled() { 1620 PROACTIVE_KILLS_ENABLED = DeviceConfig.getBoolean( 1621 DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, 1622 KEY_PROACTIVE_KILLS_ENABLED, 1623 DEFAULT_PROACTIVE_KILLS_ENABLED); 1624 } 1625 1626 private void updateLowSwapThresholdPercent() { 1627 LOW_SWAP_THRESHOLD_PERCENT = DeviceConfig.getFloat( 1628 DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, 1629 KEY_LOW_SWAP_THRESHOLD_PERCENT, 1630 DEFAULT_LOW_SWAP_THRESHOLD_PERCENT); 1631 } 1632 1633 private void updateMinAssocLogDuration() { 1634 MIN_ASSOC_LOG_DURATION = DeviceConfig.getLong( 1635 DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, KEY_MIN_ASSOC_LOG_DURATION, 1636 /* defaultValue */ DEFAULT_MIN_ASSOC_LOG_DURATION); 1637 } 1638 1639 private void updateBinderHeavyHitterWatcher() { 1640 BINDER_HEAVY_HITTER_WATCHER_ENABLED = DeviceConfig.getBoolean( 1641 DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, KEY_BINDER_HEAVY_HITTER_WATCHER_ENABLED, 1642 mDefaultBinderHeavyHitterWatcherEnabled); 1643 BINDER_HEAVY_HITTER_WATCHER_BATCHSIZE = DeviceConfig.getInt( 1644 DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, KEY_BINDER_HEAVY_HITTER_WATCHER_BATCHSIZE, 1645 mDefaultBinderHeavyHitterWatcherBatchSize); 1646 BINDER_HEAVY_HITTER_WATCHER_THRESHOLD = DeviceConfig.getFloat( 1647 DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, KEY_BINDER_HEAVY_HITTER_WATCHER_THRESHOLD, 1648 mDefaultBinderHeavyHitterWatcherThreshold); 1649 BINDER_HEAVY_HITTER_AUTO_SAMPLER_ENABLED = DeviceConfig.getBoolean( 1650 DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, 1651 KEY_BINDER_HEAVY_HITTER_AUTO_SAMPLER_ENABLED, 1652 mDefaultBinderHeavyHitterAutoSamplerEnabled); 1653 BINDER_HEAVY_HITTER_AUTO_SAMPLER_BATCHSIZE = DeviceConfig.getInt( 1654 DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, 1655 KEY_BINDER_HEAVY_HITTER_AUTO_SAMPLER_BATCHSIZE, 1656 mDefaultBinderHeavyHitterAutoSamplerBatchSize); 1657 BINDER_HEAVY_HITTER_WATCHER_THRESHOLD = DeviceConfig.getFloat( 1658 DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, 1659 KEY_BINDER_HEAVY_HITTER_AUTO_SAMPLER_THRESHOLD, 1660 mDefaultBinderHeavyHitterAutoSamplerThreshold); 1661 mService.scheduleUpdateBinderHeavyHitterWatcherConfig(); 1662 } 1663 1664 private void updateMaxPhantomProcesses() { 1665 final int oldVal = MAX_PHANTOM_PROCESSES; 1666 MAX_PHANTOM_PROCESSES = DeviceConfig.getInt( 1667 DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, KEY_MAX_PHANTOM_PROCESSES, 1668 DEFAULT_MAX_PHANTOM_PROCESSES); 1669 if (oldVal > MAX_PHANTOM_PROCESSES) { 1670 mService.mHandler.post(mService.mPhantomProcessList::trimPhantomProcessesIfNecessary); 1671 } 1672 } 1673 1674 @NeverCompile // Avoid size overhead of debugging code. 1675 void dump(PrintWriter pw) { 1676 pw.println("ACTIVITY MANAGER SETTINGS (dumpsys activity settings) " 1677 + Settings.Global.ACTIVITY_MANAGER_CONSTANTS + ":"); 1678 1679 pw.print(" "); pw.print(KEY_MAX_CACHED_PROCESSES); pw.print("="); 1680 pw.println(MAX_CACHED_PROCESSES); 1681 pw.print(" "); pw.print(KEY_BACKGROUND_SETTLE_TIME); pw.print("="); 1682 pw.println(BACKGROUND_SETTLE_TIME); 1683 pw.print(" "); pw.print(KEY_FGSERVICE_MIN_SHOWN_TIME); pw.print("="); 1684 pw.println(FGSERVICE_MIN_SHOWN_TIME); 1685 pw.print(" "); pw.print(KEY_FGSERVICE_MIN_REPORT_TIME); pw.print("="); 1686 pw.println(FGSERVICE_MIN_REPORT_TIME); 1687 pw.print(" "); pw.print(KEY_FGSERVICE_SCREEN_ON_BEFORE_TIME); pw.print("="); 1688 pw.println(FGSERVICE_SCREEN_ON_BEFORE_TIME); 1689 pw.print(" "); pw.print(KEY_FGSERVICE_SCREEN_ON_AFTER_TIME); pw.print("="); 1690 pw.println(FGSERVICE_SCREEN_ON_AFTER_TIME); 1691 pw.print(" "); pw.print(KEY_CONTENT_PROVIDER_RETAIN_TIME); pw.print("="); 1692 pw.println(CONTENT_PROVIDER_RETAIN_TIME); 1693 pw.print(" "); pw.print(KEY_GC_TIMEOUT); pw.print("="); 1694 pw.println(GC_TIMEOUT); 1695 pw.print(" "); pw.print(KEY_GC_MIN_INTERVAL); pw.print("="); 1696 pw.println(GC_MIN_INTERVAL); 1697 pw.print(" "); pw.print(KEY_FORCE_BACKGROUND_CHECK_ON_RESTRICTED_APPS); pw.print("="); 1698 pw.println(FORCE_BACKGROUND_CHECK_ON_RESTRICTED_APPS); 1699 pw.print(" "); pw.print(KEY_FULL_PSS_MIN_INTERVAL); pw.print("="); 1700 pw.println(FULL_PSS_MIN_INTERVAL); 1701 pw.print(" "); pw.print(KEY_FULL_PSS_LOWERED_INTERVAL); pw.print("="); 1702 pw.println(FULL_PSS_LOWERED_INTERVAL); 1703 pw.print(" "); pw.print(KEY_POWER_CHECK_INTERVAL); pw.print("="); 1704 pw.println(POWER_CHECK_INTERVAL); 1705 pw.print(" "); pw.print(KEY_POWER_CHECK_MAX_CPU_1); pw.print("="); 1706 pw.println(POWER_CHECK_MAX_CPU_1); 1707 pw.print(" "); pw.print(KEY_POWER_CHECK_MAX_CPU_2); pw.print("="); 1708 pw.println(POWER_CHECK_MAX_CPU_2); 1709 pw.print(" "); pw.print(KEY_POWER_CHECK_MAX_CPU_3); pw.print("="); 1710 pw.println(POWER_CHECK_MAX_CPU_3); 1711 pw.print(" "); pw.print(KEY_POWER_CHECK_MAX_CPU_4); pw.print("="); 1712 pw.println(POWER_CHECK_MAX_CPU_4); 1713 pw.print(" "); pw.print(KEY_SERVICE_USAGE_INTERACTION_TIME_PRE_S); pw.print("="); 1714 pw.println(SERVICE_USAGE_INTERACTION_TIME_PRE_S); 1715 pw.print(" "); pw.print(KEY_SERVICE_USAGE_INTERACTION_TIME_POST_S); pw.print("="); 1716 pw.println(SERVICE_USAGE_INTERACTION_TIME_POST_S); 1717 pw.print(" "); pw.print(KEY_USAGE_STATS_INTERACTION_INTERVAL_PRE_S); pw.print("="); 1718 pw.println(USAGE_STATS_INTERACTION_INTERVAL_PRE_S); 1719 pw.print(" "); pw.print(KEY_USAGE_STATS_INTERACTION_INTERVAL_POST_S); pw.print("="); 1720 pw.println(USAGE_STATS_INTERACTION_INTERVAL_POST_S); 1721 pw.print(" "); pw.print(KEY_SERVICE_RESTART_DURATION); pw.print("="); 1722 pw.println(SERVICE_RESTART_DURATION); 1723 pw.print(" "); pw.print(KEY_SERVICE_RESET_RUN_DURATION); pw.print("="); 1724 pw.println(SERVICE_RESET_RUN_DURATION); 1725 pw.print(" "); pw.print(KEY_SERVICE_RESTART_DURATION_FACTOR); pw.print("="); 1726 pw.println(SERVICE_RESTART_DURATION_FACTOR); 1727 pw.print(" "); pw.print(KEY_SERVICE_MIN_RESTART_TIME_BETWEEN); pw.print("="); 1728 pw.println(SERVICE_MIN_RESTART_TIME_BETWEEN); 1729 pw.print(" "); pw.print(KEY_MAX_SERVICE_INACTIVITY); pw.print("="); 1730 pw.println(MAX_SERVICE_INACTIVITY); 1731 pw.print(" "); pw.print(KEY_BG_START_TIMEOUT); pw.print("="); 1732 pw.println(BG_START_TIMEOUT); 1733 pw.print(" "); pw.print(KEY_SERVICE_BG_ACTIVITY_START_TIMEOUT); pw.print("="); 1734 pw.println(SERVICE_BG_ACTIVITY_START_TIMEOUT); 1735 pw.print(" "); pw.print(KEY_BOUND_SERVICE_CRASH_RESTART_DURATION); pw.print("="); 1736 pw.println(BOUND_SERVICE_CRASH_RESTART_DURATION); 1737 pw.print(" "); pw.print(KEY_BOUND_SERVICE_CRASH_MAX_RETRY); pw.print("="); 1738 pw.println(BOUND_SERVICE_MAX_CRASH_RETRY); 1739 pw.print(" "); pw.print(KEY_PROCESS_START_ASYNC); pw.print("="); 1740 pw.println(FLAG_PROCESS_START_ASYNC); 1741 pw.print(" "); pw.print(KEY_MEMORY_INFO_THROTTLE_TIME); pw.print("="); 1742 pw.println(MEMORY_INFO_THROTTLE_TIME); 1743 pw.print(" "); pw.print(KEY_TOP_TO_FGS_GRACE_DURATION); pw.print("="); 1744 pw.println(TOP_TO_FGS_GRACE_DURATION); 1745 pw.print(" "); pw.print(KEY_TOP_TO_ALMOST_PERCEPTIBLE_GRACE_DURATION); pw.print("="); 1746 pw.println(TOP_TO_ALMOST_PERCEPTIBLE_GRACE_DURATION); 1747 pw.print(" "); pw.print(KEY_MIN_CRASH_INTERVAL); pw.print("="); 1748 pw.println(MIN_CRASH_INTERVAL); 1749 pw.print(" "); pw.print(KEY_PROCESS_CRASH_COUNT_RESET_INTERVAL); pw.print("="); 1750 pw.println(PROCESS_CRASH_COUNT_RESET_INTERVAL); 1751 pw.print(" "); pw.print(KEY_PROCESS_CRASH_COUNT_LIMIT); pw.print("="); 1752 pw.println(PROCESS_CRASH_COUNT_LIMIT); 1753 pw.print(" "); pw.print(KEY_IMPERCEPTIBLE_KILL_EXEMPT_PROC_STATES); pw.print("="); 1754 pw.println(Arrays.toString(IMPERCEPTIBLE_KILL_EXEMPT_PROC_STATES.toArray())); 1755 pw.print(" "); pw.print(KEY_IMPERCEPTIBLE_KILL_EXEMPT_PACKAGES); pw.print("="); 1756 pw.println(Arrays.toString(IMPERCEPTIBLE_KILL_EXEMPT_PACKAGES.toArray())); 1757 pw.print(" "); pw.print(KEY_MIN_ASSOC_LOG_DURATION); pw.print("="); 1758 pw.println(MIN_ASSOC_LOG_DURATION); 1759 pw.print(" "); pw.print(KEY_BINDER_HEAVY_HITTER_WATCHER_ENABLED); pw.print("="); 1760 pw.println(BINDER_HEAVY_HITTER_WATCHER_ENABLED); 1761 pw.print(" "); pw.print(KEY_BINDER_HEAVY_HITTER_WATCHER_BATCHSIZE); pw.print("="); 1762 pw.println(BINDER_HEAVY_HITTER_WATCHER_BATCHSIZE); 1763 pw.print(" "); pw.print(KEY_BINDER_HEAVY_HITTER_WATCHER_THRESHOLD); pw.print("="); 1764 pw.println(BINDER_HEAVY_HITTER_WATCHER_THRESHOLD); 1765 pw.print(" "); pw.print(KEY_BINDER_HEAVY_HITTER_AUTO_SAMPLER_ENABLED); pw.print("="); 1766 pw.println(BINDER_HEAVY_HITTER_AUTO_SAMPLER_ENABLED); 1767 pw.print(" "); pw.print(KEY_BINDER_HEAVY_HITTER_AUTO_SAMPLER_BATCHSIZE); pw.print("="); 1768 pw.println(BINDER_HEAVY_HITTER_AUTO_SAMPLER_BATCHSIZE); 1769 pw.print(" "); pw.print(KEY_BINDER_HEAVY_HITTER_AUTO_SAMPLER_THRESHOLD); pw.print("="); 1770 pw.println(BINDER_HEAVY_HITTER_AUTO_SAMPLER_THRESHOLD); 1771 pw.print(" "); pw.print(KEY_MAX_PHANTOM_PROCESSES); pw.print("="); 1772 pw.println(MAX_PHANTOM_PROCESSES); 1773 pw.print(" "); pw.print(KEY_BOOT_TIME_TEMP_ALLOWLIST_DURATION); pw.print("="); 1774 pw.println(mBootTimeTempAllowlistDuration); 1775 pw.print(" "); pw.print(KEY_FG_TO_BG_FGS_GRACE_DURATION); pw.print("="); 1776 pw.println(mFgToBgFgsGraceDuration); 1777 pw.print(" "); pw.print(KEY_FGS_START_FOREGROUND_TIMEOUT); pw.print("="); 1778 pw.println(mFgsStartForegroundTimeoutMs); 1779 pw.print(" "); pw.print(KEY_DEFAULT_BACKGROUND_ACTIVITY_STARTS_ENABLED); pw.print("="); 1780 pw.println(mFlagBackgroundActivityStartsEnabled); 1781 pw.print(" "); pw.print(KEY_DEFAULT_BACKGROUND_FGS_STARTS_RESTRICTION_ENABLED); 1782 pw.print("="); pw.println(mFlagBackgroundFgsStartRestrictionEnabled); 1783 pw.print(" "); pw.print(KEY_DEFAULT_FGS_STARTS_RESTRICTION_ENABLED); pw.print("="); 1784 pw.println(mFlagFgsStartRestrictionEnabled); 1785 pw.print(" "); pw.print(KEY_DEFAULT_FGS_STARTS_RESTRICTION_NOTIFICATION_ENABLED); 1786 pw.print("="); 1787 pw.println(mFgsStartRestrictionNotificationEnabled); 1788 pw.print(" "); pw.print(KEY_DEFAULT_FGS_STARTS_RESTRICTION_CHECK_CALLER_TARGET_SDK); 1789 pw.print("="); pw.println(mFgsStartRestrictionCheckCallerTargetSdk); 1790 pw.print(" "); pw.print(KEY_FGS_ATOM_SAMPLE_RATE); 1791 pw.print("="); pw.println(mFgsAtomSampleRate); 1792 pw.print(" "); pw.print(KEY_FGS_START_ALLOWED_LOG_SAMPLE_RATE); 1793 pw.print("="); pw.println(mFgsStartAllowedLogSampleRate); 1794 pw.print(" "); pw.print(KEY_FGS_START_DENIED_LOG_SAMPLE_RATE); 1795 pw.print("="); pw.println(mFgsStartDeniedLogSampleRate); 1796 pw.print(" "); pw.print(KEY_PUSH_MESSAGING_OVER_QUOTA_BEHAVIOR); 1797 pw.print("="); pw.println(mPushMessagingOverQuotaBehavior); 1798 pw.print(" "); pw.print(KEY_FGS_ALLOW_OPT_OUT); 1799 pw.print("="); pw.println(mFgsAllowOptOut); 1800 pw.print(" "); pw.print(KEY_ENABLE_COMPONENT_ALIAS); 1801 pw.print("="); pw.println(mEnableComponentAlias); 1802 pw.print(" "); pw.print(KEY_COMPONENT_ALIAS_OVERRIDES); 1803 pw.print("="); pw.println(mComponentAliasOverrides); 1804 pw.print(" "); pw.print(KEY_DEFER_BOOT_COMPLETED_BROADCAST); 1805 pw.print("="); pw.println(mDeferBootCompletedBroadcast); 1806 pw.print(" "); pw.print(KEY_NO_KILL_CACHED_PROCESSES_UNTIL_BOOT_COMPLETED); 1807 pw.print("="); pw.println(mNoKillCachedProcessesUntilBootCompleted); 1808 pw.print(" "); pw.print(KEY_NO_KILL_CACHED_PROCESSES_POST_BOOT_COMPLETED_DURATION_MILLIS); 1809 pw.print("="); pw.println(mNoKillCachedProcessesPostBootCompletedDurationMillis); 1810 pw.print(" "); pw.print(KEY_MAX_EMPTY_TIME_MILLIS); 1811 pw.print("="); pw.println(mMaxEmptyTimeMillis); 1812 pw.print(" "); pw.print(KEY_SERVICE_START_FOREGROUND_TIMEOUT_MS); 1813 pw.print("="); pw.println(mServiceStartForegroundTimeoutMs); 1814 pw.print(" "); pw.print(KEY_SERVICE_START_FOREGROUND_ANR_DELAY_MS); 1815 pw.print("="); pw.println(mServiceStartForegroundAnrDelayMs); 1816 pw.print(" "); pw.print(KEY_SERVICE_BIND_ALMOST_PERCEPTIBLE_TIMEOUT_MS); 1817 pw.print("="); pw.println(mServiceBindAlmostPerceptibleTimeoutMs); 1818 pw.print(" "); pw.print(KEY_NETWORK_ACCESS_TIMEOUT_MS); 1819 pw.print("="); pw.println(mNetworkAccessTimeoutMs); 1820 pw.print(" "); pw.print(KEY_PROACTIVE_KILLS_ENABLED); 1821 pw.print("="); pw.println(PROACTIVE_KILLS_ENABLED); 1822 pw.print(" "); pw.print(KEY_LOW_SWAP_THRESHOLD_PERCENT); 1823 pw.print("="); pw.println(LOW_SWAP_THRESHOLD_PERCENT); 1824 1825 pw.println(); 1826 if (mOverrideMaxCachedProcesses >= 0) { 1827 pw.print(" mOverrideMaxCachedProcesses="); pw.println(mOverrideMaxCachedProcesses); 1828 } 1829 pw.print(" mCustomizedMaxCachedProcesses="); pw.println(mCustomizedMaxCachedProcesses); 1830 pw.print(" CUR_MAX_CACHED_PROCESSES="); pw.println(CUR_MAX_CACHED_PROCESSES); 1831 pw.print(" CUR_MAX_EMPTY_PROCESSES="); pw.println(CUR_MAX_EMPTY_PROCESSES); 1832 pw.print(" CUR_TRIM_EMPTY_PROCESSES="); pw.println(CUR_TRIM_EMPTY_PROCESSES); 1833 pw.print(" CUR_TRIM_CACHED_PROCESSES="); pw.println(CUR_TRIM_CACHED_PROCESSES); 1834 pw.print(" OOMADJ_UPDATE_QUICK="); pw.println(OOMADJ_UPDATE_QUICK); 1835 } 1836 } 1837