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