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