1 /* 2 * Copyright (C) 2006 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 android.provider; 18 19 import android.annotation.SdkConstant; 20 import android.annotation.SdkConstant.SdkConstantType; 21 import android.annotation.SystemApi; 22 import android.app.ActivityThread; 23 import android.app.AppOpsManager; 24 import android.app.Application; 25 import android.app.SearchManager; 26 import android.app.WallpaperManager; 27 import android.content.ComponentName; 28 import android.content.ContentResolver; 29 import android.content.ContentValues; 30 import android.content.Context; 31 import android.content.IContentProvider; 32 import android.content.Intent; 33 import android.content.pm.ActivityInfo; 34 import android.content.pm.PackageManager; 35 import android.content.pm.ResolveInfo; 36 import android.content.res.Configuration; 37 import android.content.res.Resources; 38 import android.database.Cursor; 39 import android.database.SQLException; 40 import android.location.LocationManager; 41 import android.net.ConnectivityManager; 42 import android.net.Uri; 43 import android.net.wifi.WifiManager; 44 import android.os.BatteryManager; 45 import android.os.Binder; 46 import android.os.Bundle; 47 import android.os.DropBoxManager; 48 import android.os.IBinder; 49 import android.os.Process; 50 import android.os.RemoteException; 51 import android.os.ServiceManager; 52 import android.os.SystemProperties; 53 import android.os.UserHandle; 54 import android.os.Build.VERSION_CODES; 55 import android.speech.tts.TextToSpeech; 56 import android.text.TextUtils; 57 import android.util.AndroidException; 58 import android.util.ArrayMap; 59 import android.util.ArraySet; 60 import android.util.Log; 61 62 import com.android.internal.util.ArrayUtils; 63 import com.android.internal.widget.ILockSettings; 64 65 import java.net.URISyntaxException; 66 import java.text.SimpleDateFormat; 67 import java.util.HashMap; 68 import java.util.HashSet; 69 import java.util.Locale; 70 import java.util.Map; 71 import java.util.Set; 72 73 /** 74 * The Settings provider contains global system-level device preferences. 75 */ 76 public final class Settings { 77 78 // Intent actions for Settings 79 80 /** 81 * Activity Action: Show system settings. 82 * <p> 83 * Input: Nothing. 84 * <p> 85 * Output: Nothing. 86 */ 87 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 88 public static final String ACTION_SETTINGS = "android.settings.SETTINGS"; 89 90 /** 91 * Activity Action: Show settings to allow configuration of APNs. 92 * <p> 93 * Input: Nothing. 94 * <p> 95 * Output: Nothing. 96 */ 97 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 98 public static final String ACTION_APN_SETTINGS = "android.settings.APN_SETTINGS"; 99 100 /** 101 * Activity Action: Show settings to allow configuration of current location 102 * sources. 103 * <p> 104 * In some cases, a matching Activity may not exist, so ensure you 105 * safeguard against this. 106 * <p> 107 * Input: Nothing. 108 * <p> 109 * Output: Nothing. 110 */ 111 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 112 public static final String ACTION_LOCATION_SOURCE_SETTINGS = 113 "android.settings.LOCATION_SOURCE_SETTINGS"; 114 115 /** 116 * Activity Action: Show settings to allow configuration of wireless controls 117 * such as Wi-Fi, Bluetooth and Mobile networks. 118 * <p> 119 * In some cases, a matching Activity may not exist, so ensure you 120 * safeguard against this. 121 * <p> 122 * Input: Nothing. 123 * <p> 124 * Output: Nothing. 125 */ 126 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 127 public static final String ACTION_WIRELESS_SETTINGS = 128 "android.settings.WIRELESS_SETTINGS"; 129 130 /** 131 * Activity Action: Show settings to allow entering/exiting airplane mode. 132 * <p> 133 * In some cases, a matching Activity may not exist, so ensure you 134 * safeguard against this. 135 * <p> 136 * Input: Nothing. 137 * <p> 138 * Output: Nothing. 139 */ 140 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 141 public static final String ACTION_AIRPLANE_MODE_SETTINGS = 142 "android.settings.AIRPLANE_MODE_SETTINGS"; 143 144 /** 145 * Activity Action: Modify Airplane mode settings using a voice command. 146 * <p> 147 * In some cases, a matching Activity may not exist, so ensure you safeguard against this. 148 * <p> 149 * This intent MUST be started using 150 * {@link android.service.voice.VoiceInteractionSession#startVoiceActivity 151 * startVoiceActivity}. 152 * <p> 153 * Note: The activity implementing this intent MUST verify that 154 * {@link android.app.Activity#isVoiceInteraction isVoiceInteraction} returns true before 155 * modifying the setting. 156 * <p> 157 * Input: To tell which state airplane mode should be set to, add the 158 * {@link #EXTRA_AIRPLANE_MODE_ENABLED} extra to this Intent with the state specified. 159 * If the extra is not included, no changes will be made. 160 * <p> 161 * Output: Nothing. 162 */ 163 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 164 public static final String ACTION_VOICE_CONTROL_AIRPLANE_MODE = 165 "android.settings.VOICE_CONTROL_AIRPLANE_MODE"; 166 167 /** 168 * Activity Action: Show settings for accessibility modules. 169 * <p> 170 * In some cases, a matching Activity may not exist, so ensure you 171 * safeguard against this. 172 * <p> 173 * Input: Nothing. 174 * <p> 175 * Output: Nothing. 176 */ 177 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 178 public static final String ACTION_ACCESSIBILITY_SETTINGS = 179 "android.settings.ACCESSIBILITY_SETTINGS"; 180 181 /** 182 * Activity Action: Show settings to control access to usage information. 183 * <p> 184 * In some cases, a matching Activity may not exist, so ensure you 185 * safeguard against this. 186 * <p> 187 * Input: Nothing. 188 * <p> 189 * Output: Nothing. 190 */ 191 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 192 public static final String ACTION_USAGE_ACCESS_SETTINGS = 193 "android.settings.USAGE_ACCESS_SETTINGS"; 194 195 /** 196 * Activity Category: Show application settings related to usage access. 197 * <p> 198 * An activity that provides a user interface for adjusting usage access related 199 * preferences for its containing application. Optional but recommended for apps that 200 * use {@link android.Manifest.permission#PACKAGE_USAGE_STATS}. 201 * <p> 202 * The activity may define meta-data to describe what usage access is 203 * used for within their app with {@link #METADATA_USAGE_ACCESS_REASON}, which 204 * will be displayed in Settings. 205 * <p> 206 * Input: Nothing. 207 * <p> 208 * Output: Nothing. 209 */ 210 @SdkConstant(SdkConstantType.INTENT_CATEGORY) 211 public static final String INTENT_CATEGORY_USAGE_ACCESS_CONFIG = 212 "android.intent.category.USAGE_ACCESS_CONFIG"; 213 214 /** 215 * Metadata key: Reason for needing usage access. 216 * <p> 217 * A key for metadata attached to an activity that receives action 218 * {@link #INTENT_CATEGORY_USAGE_ACCESS_CONFIG}, shown to the 219 * user as description of how the app uses usage access. 220 * <p> 221 */ 222 public static final String METADATA_USAGE_ACCESS_REASON = 223 "android.settings.metadata.USAGE_ACCESS_REASON"; 224 225 /** 226 * Activity Action: Show settings to allow configuration of security and 227 * location privacy. 228 * <p> 229 * In some cases, a matching Activity may not exist, so ensure you 230 * safeguard against this. 231 * <p> 232 * Input: Nothing. 233 * <p> 234 * Output: Nothing. 235 */ 236 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 237 public static final String ACTION_SECURITY_SETTINGS = 238 "android.settings.SECURITY_SETTINGS"; 239 240 /** 241 * Activity Action: Show trusted credentials settings, opening to the user tab, 242 * to allow management of installed credentials. 243 * <p> 244 * In some cases, a matching Activity may not exist, so ensure you 245 * safeguard against this. 246 * <p> 247 * Input: Nothing. 248 * <p> 249 * Output: Nothing. 250 * @hide 251 */ 252 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 253 public static final String ACTION_TRUSTED_CREDENTIALS_USER = 254 "com.android.settings.TRUSTED_CREDENTIALS_USER"; 255 256 /** 257 * Activity Action: Show dialog explaining that an installed CA cert may enable 258 * monitoring of encrypted network traffic. 259 * <p> 260 * In some cases, a matching Activity may not exist, so ensure you 261 * safeguard against this. 262 * <p> 263 * Input: Nothing. 264 * <p> 265 * Output: Nothing. 266 * @hide 267 */ 268 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 269 public static final String ACTION_MONITORING_CERT_INFO = 270 "com.android.settings.MONITORING_CERT_INFO"; 271 272 /** 273 * Activity Action: Show settings to allow configuration of privacy options. 274 * <p> 275 * In some cases, a matching Activity may not exist, so ensure you 276 * safeguard against this. 277 * <p> 278 * Input: Nothing. 279 * <p> 280 * Output: Nothing. 281 */ 282 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 283 public static final String ACTION_PRIVACY_SETTINGS = 284 "android.settings.PRIVACY_SETTINGS"; 285 286 /** 287 * Activity Action: Show settings to allow configuration of Wi-Fi. 288 * <p> 289 * In some cases, a matching Activity may not exist, so ensure you 290 * safeguard against this. 291 * <p> 292 * Input: Nothing. 293 * <p> 294 * Output: Nothing. 295 296 */ 297 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 298 public static final String ACTION_WIFI_SETTINGS = 299 "android.settings.WIFI_SETTINGS"; 300 301 /** 302 * Activity Action: Show settings to allow configuration of a static IP 303 * address for Wi-Fi. 304 * <p> 305 * In some cases, a matching Activity may not exist, so ensure you safeguard 306 * against this. 307 * <p> 308 * Input: Nothing. 309 * <p> 310 * Output: Nothing. 311 */ 312 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 313 public static final String ACTION_WIFI_IP_SETTINGS = 314 "android.settings.WIFI_IP_SETTINGS"; 315 316 /** 317 * Activity Action: Show settings to allow configuration of Bluetooth. 318 * <p> 319 * In some cases, a matching Activity may not exist, so ensure you 320 * safeguard against this. 321 * <p> 322 * Input: Nothing. 323 * <p> 324 * Output: Nothing. 325 */ 326 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 327 public static final String ACTION_BLUETOOTH_SETTINGS = 328 "android.settings.BLUETOOTH_SETTINGS"; 329 330 /** 331 * Activity Action: Show settings to allow configuration of cast endpoints. 332 * <p> 333 * In some cases, a matching Activity may not exist, so ensure you 334 * safeguard against this. 335 * <p> 336 * Input: Nothing. 337 * <p> 338 * Output: Nothing. 339 */ 340 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 341 public static final String ACTION_CAST_SETTINGS = 342 "android.settings.CAST_SETTINGS"; 343 344 /** 345 * Activity Action: Show settings to allow configuration of date and time. 346 * <p> 347 * In some cases, a matching Activity may not exist, so ensure you 348 * safeguard against this. 349 * <p> 350 * Input: Nothing. 351 * <p> 352 * Output: Nothing. 353 */ 354 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 355 public static final String ACTION_DATE_SETTINGS = 356 "android.settings.DATE_SETTINGS"; 357 358 /** 359 * Activity Action: Show settings to allow configuration of sound and volume. 360 * <p> 361 * In some cases, a matching Activity may not exist, so ensure you 362 * safeguard against this. 363 * <p> 364 * Input: Nothing. 365 * <p> 366 * Output: Nothing. 367 */ 368 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 369 public static final String ACTION_SOUND_SETTINGS = 370 "android.settings.SOUND_SETTINGS"; 371 372 /** 373 * Activity Action: Show settings to allow configuration of display. 374 * <p> 375 * In some cases, a matching Activity may not exist, so ensure you 376 * safeguard against this. 377 * <p> 378 * Input: Nothing. 379 * <p> 380 * Output: Nothing. 381 */ 382 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 383 public static final String ACTION_DISPLAY_SETTINGS = 384 "android.settings.DISPLAY_SETTINGS"; 385 386 /** 387 * Activity Action: Show settings to allow configuration of locale. 388 * <p> 389 * In some cases, a matching Activity may not exist, so ensure you 390 * safeguard against this. 391 * <p> 392 * Input: Nothing. 393 * <p> 394 * Output: Nothing. 395 */ 396 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 397 public static final String ACTION_LOCALE_SETTINGS = 398 "android.settings.LOCALE_SETTINGS"; 399 400 /** 401 * Activity Action: Show settings to configure input methods, in particular 402 * allowing the user to enable input methods. 403 * <p> 404 * In some cases, a matching Activity may not exist, so ensure you 405 * safeguard against this. 406 * <p> 407 * Input: Nothing. 408 * <p> 409 * Output: Nothing. 410 */ 411 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 412 public static final String ACTION_VOICE_INPUT_SETTINGS = 413 "android.settings.VOICE_INPUT_SETTINGS"; 414 415 /** 416 * Activity Action: Show settings to configure input methods, in particular 417 * allowing the user to enable input methods. 418 * <p> 419 * In some cases, a matching Activity may not exist, so ensure you 420 * safeguard against this. 421 * <p> 422 * Input: Nothing. 423 * <p> 424 * Output: Nothing. 425 */ 426 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 427 public static final String ACTION_INPUT_METHOD_SETTINGS = 428 "android.settings.INPUT_METHOD_SETTINGS"; 429 430 /** 431 * Activity Action: Show settings to enable/disable input method subtypes. 432 * <p> 433 * In some cases, a matching Activity may not exist, so ensure you 434 * safeguard against this. 435 * <p> 436 * To tell which input method's subtypes are displayed in the settings, add 437 * {@link #EXTRA_INPUT_METHOD_ID} extra to this Intent with the input method id. 438 * If there is no extra in this Intent, subtypes from all installed input methods 439 * will be displayed in the settings. 440 * 441 * @see android.view.inputmethod.InputMethodInfo#getId 442 * <p> 443 * Input: Nothing. 444 * <p> 445 * Output: Nothing. 446 */ 447 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 448 public static final String ACTION_INPUT_METHOD_SUBTYPE_SETTINGS = 449 "android.settings.INPUT_METHOD_SUBTYPE_SETTINGS"; 450 451 /** 452 * Activity Action: Show a dialog to select input method. 453 * <p> 454 * In some cases, a matching Activity may not exist, so ensure you 455 * safeguard against this. 456 * <p> 457 * Input: Nothing. 458 * <p> 459 * Output: Nothing. 460 * @hide 461 */ 462 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 463 public static final String ACTION_SHOW_INPUT_METHOD_PICKER = 464 "android.settings.SHOW_INPUT_METHOD_PICKER"; 465 466 /** 467 * Activity Action: Show settings to manage the user input dictionary. 468 * <p> 469 * Starting with {@link android.os.Build.VERSION_CODES#KITKAT}, 470 * it is guaranteed there will always be an appropriate implementation for this Intent action. 471 * In prior releases of the platform this was optional, so ensure you safeguard against it. 472 * <p> 473 * Input: Nothing. 474 * <p> 475 * Output: Nothing. 476 */ 477 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 478 public static final String ACTION_USER_DICTIONARY_SETTINGS = 479 "android.settings.USER_DICTIONARY_SETTINGS"; 480 481 /** 482 * Activity Action: Adds a word to the user dictionary. 483 * <p> 484 * In some cases, a matching Activity may not exist, so ensure you 485 * safeguard against this. 486 * <p> 487 * Input: An extra with key <code>word</code> that contains the word 488 * that should be added to the dictionary. 489 * <p> 490 * Output: Nothing. 491 * 492 * @hide 493 */ 494 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 495 public static final String ACTION_USER_DICTIONARY_INSERT = 496 "com.android.settings.USER_DICTIONARY_INSERT"; 497 498 /** 499 * Activity Action: Show settings to allow configuration of application-related settings. 500 * <p> 501 * In some cases, a matching Activity may not exist, so ensure you 502 * safeguard against this. 503 * <p> 504 * Input: Nothing. 505 * <p> 506 * Output: Nothing. 507 */ 508 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 509 public static final String ACTION_APPLICATION_SETTINGS = 510 "android.settings.APPLICATION_SETTINGS"; 511 512 /** 513 * Activity Action: Show settings to allow configuration of application 514 * development-related settings. As of 515 * {@link android.os.Build.VERSION_CODES#JELLY_BEAN_MR1} this action is 516 * a required part of the platform. 517 * <p> 518 * Input: Nothing. 519 * <p> 520 * Output: Nothing. 521 */ 522 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 523 public static final String ACTION_APPLICATION_DEVELOPMENT_SETTINGS = 524 "android.settings.APPLICATION_DEVELOPMENT_SETTINGS"; 525 526 /** 527 * Activity Action: Show settings to allow configuration of quick launch shortcuts. 528 * <p> 529 * In some cases, a matching Activity may not exist, so ensure you 530 * safeguard against this. 531 * <p> 532 * Input: Nothing. 533 * <p> 534 * Output: Nothing. 535 */ 536 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 537 public static final String ACTION_QUICK_LAUNCH_SETTINGS = 538 "android.settings.QUICK_LAUNCH_SETTINGS"; 539 540 /** 541 * Activity Action: Show settings to manage installed applications. 542 * <p> 543 * In some cases, a matching Activity may not exist, so ensure you 544 * safeguard against this. 545 * <p> 546 * Input: Nothing. 547 * <p> 548 * Output: Nothing. 549 */ 550 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 551 public static final String ACTION_MANAGE_APPLICATIONS_SETTINGS = 552 "android.settings.MANAGE_APPLICATIONS_SETTINGS"; 553 554 /** 555 * Activity Action: Show settings to manage all applications. 556 * <p> 557 * In some cases, a matching Activity may not exist, so ensure you 558 * safeguard against this. 559 * <p> 560 * Input: Nothing. 561 * <p> 562 * Output: Nothing. 563 */ 564 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 565 public static final String ACTION_MANAGE_ALL_APPLICATIONS_SETTINGS = 566 "android.settings.MANAGE_ALL_APPLICATIONS_SETTINGS"; 567 568 /** 569 * Activity Action: Show screen for controlling which apps can draw on top of other apps. 570 * <p> 571 * In some cases, a matching Activity may not exist, so ensure you 572 * safeguard against this. 573 * <p> 574 * Input: Optionally, the Intent's data URI can specify the application package name to 575 * directly invoke the management GUI specific to the package name. For example 576 * "package:com.my.app". 577 * <p> 578 * Output: Nothing. 579 */ 580 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 581 public static final String ACTION_MANAGE_OVERLAY_PERMISSION = 582 "android.settings.action.MANAGE_OVERLAY_PERMISSION"; 583 584 /** 585 * Activity Action: Show screen for controlling which apps are allowed to write/modify 586 * system settings. 587 * <p> 588 * In some cases, a matching Activity may not exist, so ensure you 589 * safeguard against this. 590 * <p> 591 * Input: Optionally, the Intent's data URI can specify the application package name to 592 * directly invoke the management GUI specific to the package name. For example 593 * "package:com.my.app". 594 * <p> 595 * Output: Nothing. 596 */ 597 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 598 public static final String ACTION_MANAGE_WRITE_SETTINGS = 599 "android.settings.action.MANAGE_WRITE_SETTINGS"; 600 601 /** 602 * Activity Action: Show screen of details about a particular application. 603 * <p> 604 * In some cases, a matching Activity may not exist, so ensure you 605 * safeguard against this. 606 * <p> 607 * Input: The Intent's data URI specifies the application package name 608 * to be shown, with the "package" scheme. That is "package:com.my.app". 609 * <p> 610 * Output: Nothing. 611 */ 612 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 613 public static final String ACTION_APPLICATION_DETAILS_SETTINGS = 614 "android.settings.APPLICATION_DETAILS_SETTINGS"; 615 616 /** 617 * Activity Action: Show screen for controlling which apps can ignore battery optimizations. 618 * <p> 619 * Input: Nothing. 620 * <p> 621 * Output: Nothing. 622 * <p> 623 * You can use {@link android.os.PowerManager#isIgnoringBatteryOptimizations 624 * PowerManager.isIgnoringBatteryOptimizations()} to determine if an application is 625 * already ignoring optimizations. You can use 626 * {@link #ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS} to ask the user to put you 627 * on this list. 628 */ 629 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 630 public static final String ACTION_IGNORE_BATTERY_OPTIMIZATION_SETTINGS = 631 "android.settings.IGNORE_BATTERY_OPTIMIZATION_SETTINGS"; 632 633 /** 634 * Activity Action: Ask the user to allow an to ignore battery optimizations (that is, 635 * put them on the whitelist of apps shown by 636 * {@link #ACTION_IGNORE_BATTERY_OPTIMIZATION_SETTINGS}). For an app to use this, it also 637 * must hold the {@link android.Manifest.permission#REQUEST_IGNORE_BATTERY_OPTIMIZATIONS} 638 * permission. 639 * <p><b>Note:</b> most applications should <em>not</em> use this; there are many facilities 640 * provided by the platform for applications to operate correctly in the various power 641 * saving mode. This is only for unusual applications that need to deeply control their own 642 * execution, at the potential expense of the user's battery life. Note that these applications 643 * greatly run the risk of showing to the user has how power consumers on their device.</p> 644 * <p> 645 * Input: The Intent's data URI must specify the application package name 646 * to be shown, with the "package" scheme. That is "package:com.my.app". 647 * <p> 648 * Output: Nothing. 649 * <p> 650 * You can use {@link android.os.PowerManager#isIgnoringBatteryOptimizations 651 * PowerManager.isIgnoringBatteryOptimizations()} to determine if an application is 652 * already ignoring optimizations. 653 */ 654 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 655 public static final String ACTION_REQUEST_IGNORE_BATTERY_OPTIMIZATIONS = 656 "android.settings.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS"; 657 658 /** 659 * @hide 660 * Activity Action: Show the "app ops" settings screen. 661 * <p> 662 * Input: Nothing. 663 * <p> 664 * Output: Nothing. 665 */ 666 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 667 public static final String ACTION_APP_OPS_SETTINGS = 668 "android.settings.APP_OPS_SETTINGS"; 669 670 /** 671 * Activity Action: Show settings for system update functionality. 672 * <p> 673 * In some cases, a matching Activity may not exist, so ensure you 674 * safeguard against this. 675 * <p> 676 * Input: Nothing. 677 * <p> 678 * Output: Nothing. 679 * 680 * @hide 681 */ 682 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 683 public static final String ACTION_SYSTEM_UPDATE_SETTINGS = 684 "android.settings.SYSTEM_UPDATE_SETTINGS"; 685 686 /** 687 * Activity Action: Show settings to allow configuration of sync settings. 688 * <p> 689 * In some cases, a matching Activity may not exist, so ensure you 690 * safeguard against this. 691 * <p> 692 * The account types available to add via the add account button may be restricted by adding an 693 * {@link #EXTRA_AUTHORITIES} extra to this Intent with one or more syncable content provider's 694 * authorities. Only account types which can sync with that content provider will be offered to 695 * the user. 696 * <p> 697 * Input: Nothing. 698 * <p> 699 * Output: Nothing. 700 */ 701 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 702 public static final String ACTION_SYNC_SETTINGS = 703 "android.settings.SYNC_SETTINGS"; 704 705 /** 706 * Activity Action: Show add account screen for creating a new account. 707 * <p> 708 * In some cases, a matching Activity may not exist, so ensure you 709 * safeguard against this. 710 * <p> 711 * The account types available to add may be restricted by adding an {@link #EXTRA_AUTHORITIES} 712 * extra to the Intent with one or more syncable content provider's authorities. Only account 713 * types which can sync with that content provider will be offered to the user. 714 * <p> 715 * Account types can also be filtered by adding an {@link #EXTRA_ACCOUNT_TYPES} extra to the 716 * Intent with one or more account types. 717 * <p> 718 * Input: Nothing. 719 * <p> 720 * Output: Nothing. 721 */ 722 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 723 public static final String ACTION_ADD_ACCOUNT = 724 "android.settings.ADD_ACCOUNT_SETTINGS"; 725 726 /** 727 * Activity Action: Show settings for selecting the network operator. 728 * <p> 729 * In some cases, a matching Activity may not exist, so ensure you 730 * safeguard against this. 731 * <p> 732 * Input: Nothing. 733 * <p> 734 * Output: Nothing. 735 */ 736 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 737 public static final String ACTION_NETWORK_OPERATOR_SETTINGS = 738 "android.settings.NETWORK_OPERATOR_SETTINGS"; 739 740 /** 741 * Activity Action: Show settings for selection of 2G/3G. 742 * <p> 743 * In some cases, a matching Activity may not exist, so ensure you 744 * safeguard against this. 745 * <p> 746 * Input: Nothing. 747 * <p> 748 * Output: Nothing. 749 */ 750 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 751 public static final String ACTION_DATA_ROAMING_SETTINGS = 752 "android.settings.DATA_ROAMING_SETTINGS"; 753 754 /** 755 * Activity Action: Show settings for internal storage. 756 * <p> 757 * In some cases, a matching Activity may not exist, so ensure you 758 * safeguard against this. 759 * <p> 760 * Input: Nothing. 761 * <p> 762 * Output: Nothing. 763 */ 764 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 765 public static final String ACTION_INTERNAL_STORAGE_SETTINGS = 766 "android.settings.INTERNAL_STORAGE_SETTINGS"; 767 /** 768 * Activity Action: Show settings for memory card storage. 769 * <p> 770 * In some cases, a matching Activity may not exist, so ensure you 771 * safeguard against this. 772 * <p> 773 * Input: Nothing. 774 * <p> 775 * Output: Nothing. 776 */ 777 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 778 public static final String ACTION_MEMORY_CARD_SETTINGS = 779 "android.settings.MEMORY_CARD_SETTINGS"; 780 781 /** 782 * Activity Action: Show settings for global search. 783 * <p> 784 * In some cases, a matching Activity may not exist, so ensure you 785 * safeguard against this. 786 * <p> 787 * Input: Nothing. 788 * <p> 789 * Output: Nothing 790 */ 791 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 792 public static final String ACTION_SEARCH_SETTINGS = 793 "android.search.action.SEARCH_SETTINGS"; 794 795 /** 796 * Activity Action: Show general device information settings (serial 797 * number, software version, phone number, etc.). 798 * <p> 799 * In some cases, a matching Activity may not exist, so ensure you 800 * safeguard against this. 801 * <p> 802 * Input: Nothing. 803 * <p> 804 * Output: Nothing 805 */ 806 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 807 public static final String ACTION_DEVICE_INFO_SETTINGS = 808 "android.settings.DEVICE_INFO_SETTINGS"; 809 810 /** 811 * Activity Action: Show NFC settings. 812 * <p> 813 * This shows UI that allows NFC to be turned on or off. 814 * <p> 815 * In some cases, a matching Activity may not exist, so ensure you 816 * safeguard against this. 817 * <p> 818 * Input: Nothing. 819 * <p> 820 * Output: Nothing 821 * @see android.nfc.NfcAdapter#isEnabled() 822 */ 823 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 824 public static final String ACTION_NFC_SETTINGS = "android.settings.NFC_SETTINGS"; 825 826 /** 827 * Activity Action: Show NFC Sharing settings. 828 * <p> 829 * This shows UI that allows NDEF Push (Android Beam) to be turned on or 830 * off. 831 * <p> 832 * In some cases, a matching Activity may not exist, so ensure you 833 * safeguard against this. 834 * <p> 835 * Input: Nothing. 836 * <p> 837 * Output: Nothing 838 * @see android.nfc.NfcAdapter#isNdefPushEnabled() 839 */ 840 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 841 public static final String ACTION_NFCSHARING_SETTINGS = 842 "android.settings.NFCSHARING_SETTINGS"; 843 844 /** 845 * Activity Action: Show NFC Tap & Pay settings 846 * <p> 847 * This shows UI that allows the user to configure Tap&Pay 848 * settings. 849 * <p> 850 * In some cases, a matching Activity may not exist, so ensure you 851 * safeguard against this. 852 * <p> 853 * Input: Nothing. 854 * <p> 855 * Output: Nothing 856 */ 857 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 858 public static final String ACTION_NFC_PAYMENT_SETTINGS = 859 "android.settings.NFC_PAYMENT_SETTINGS"; 860 861 /** 862 * Activity Action: Show Daydream settings. 863 * <p> 864 * In some cases, a matching Activity may not exist, so ensure you 865 * safeguard against this. 866 * <p> 867 * Input: Nothing. 868 * <p> 869 * Output: Nothing. 870 * @see android.service.dreams.DreamService 871 */ 872 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 873 public static final String ACTION_DREAM_SETTINGS = "android.settings.DREAM_SETTINGS"; 874 875 /** 876 * Activity Action: Show Notification listener settings. 877 * <p> 878 * In some cases, a matching Activity may not exist, so ensure you 879 * safeguard against this. 880 * <p> 881 * Input: Nothing. 882 * <p> 883 * Output: Nothing. 884 * @see android.service.notification.NotificationListenerService 885 */ 886 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 887 public static final String ACTION_NOTIFICATION_LISTENER_SETTINGS 888 = "android.settings.ACTION_NOTIFICATION_LISTENER_SETTINGS"; 889 890 /** 891 * Activity Action: Show Do Not Disturb access settings. 892 * <p> 893 * Users can grant and deny access to Do Not Disturb configuration from here. 894 * See {@link android.app.NotificationManager#isNotificationPolicyAccessGranted()} for more 895 * details. 896 * <p> 897 * Input: Nothing. 898 * <p> 899 * Output: Nothing. 900 */ 901 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 902 public static final String ACTION_NOTIFICATION_POLICY_ACCESS_SETTINGS 903 = "android.settings.NOTIFICATION_POLICY_ACCESS_SETTINGS"; 904 905 /** 906 * @hide 907 */ 908 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 909 public static final String ACTION_CONDITION_PROVIDER_SETTINGS 910 = "android.settings.ACTION_CONDITION_PROVIDER_SETTINGS"; 911 912 /** 913 * Activity Action: Show settings for video captioning. 914 * <p> 915 * In some cases, a matching Activity may not exist, so ensure you safeguard 916 * against this. 917 * <p> 918 * Input: Nothing. 919 * <p> 920 * Output: Nothing. 921 */ 922 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 923 public static final String ACTION_CAPTIONING_SETTINGS = "android.settings.CAPTIONING_SETTINGS"; 924 925 /** 926 * Activity Action: Show the top level print settings. 927 * <p> 928 * In some cases, a matching Activity may not exist, so ensure you 929 * safeguard against this. 930 * <p> 931 * Input: Nothing. 932 * <p> 933 * Output: Nothing. 934 */ 935 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 936 public static final String ACTION_PRINT_SETTINGS = 937 "android.settings.ACTION_PRINT_SETTINGS"; 938 939 /** 940 * Activity Action: Show Zen Mode configuration settings. 941 * 942 * @hide 943 */ 944 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 945 public static final String ACTION_ZEN_MODE_SETTINGS = "android.settings.ZEN_MODE_SETTINGS"; 946 947 /** 948 * Activity Action: Show Zen Mode priority configuration settings. 949 * 950 * @hide 951 */ 952 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 953 public static final String ACTION_ZEN_MODE_PRIORITY_SETTINGS 954 = "android.settings.ZEN_MODE_PRIORITY_SETTINGS"; 955 956 /** 957 * Activity Action: Show Zen Mode automation configuration settings. 958 * 959 * @hide 960 */ 961 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 962 public static final String ACTION_ZEN_MODE_AUTOMATION_SETTINGS 963 = "android.settings.ZEN_MODE_AUTOMATION_SETTINGS"; 964 965 /** 966 * Activity Action: Modify do not disturb mode settings. 967 * <p> 968 * In some cases, a matching Activity may not exist, so ensure you safeguard against this. 969 * <p> 970 * This intent MUST be started using 971 * {@link android.service.voice.VoiceInteractionSession#startVoiceActivity 972 * startVoiceActivity}. 973 * <p> 974 * Note: The Activity implementing this intent MUST verify that 975 * {@link android.app.Activity#isVoiceInteraction isVoiceInteraction}. 976 * returns true before modifying the setting. 977 * <p> 978 * Input: The optional {@link #EXTRA_DO_NOT_DISTURB_MODE_MINUTES} extra can be used to indicate 979 * how long the user wishes to avoid interruptions for. The optional 980 * {@link #EXTRA_DO_NOT_DISTURB_MODE_ENABLED} extra can be to indicate if the user is 981 * enabling or disabling do not disturb mode. If either extra is not included, the 982 * user maybe asked to provide the value. 983 * <p> 984 * Output: Nothing. 985 */ 986 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 987 public static final String ACTION_VOICE_CONTROL_DO_NOT_DISTURB_MODE = 988 "android.settings.VOICE_CONTROL_DO_NOT_DISTURB_MODE"; 989 990 /** 991 * Activity Action: Show Zen Mode schedule rule configuration settings. 992 * 993 * @hide 994 */ 995 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 996 public static final String ACTION_ZEN_MODE_SCHEDULE_RULE_SETTINGS 997 = "android.settings.ZEN_MODE_SCHEDULE_RULE_SETTINGS"; 998 999 /** 1000 * Activity Action: Show Zen Mode event rule configuration settings. 1001 * 1002 * @hide 1003 */ 1004 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 1005 public static final String ACTION_ZEN_MODE_EVENT_RULE_SETTINGS 1006 = "android.settings.ZEN_MODE_EVENT_RULE_SETTINGS"; 1007 1008 /** 1009 * Activity Action: Show Zen Mode external rule configuration settings. 1010 * 1011 * @hide 1012 */ 1013 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 1014 public static final String ACTION_ZEN_MODE_EXTERNAL_RULE_SETTINGS 1015 = "android.settings.ZEN_MODE_EXTERNAL_RULE_SETTINGS"; 1016 1017 /** 1018 * Activity Action: Show the regulatory information screen for the device. 1019 * <p> 1020 * In some cases, a matching Activity may not exist, so ensure you safeguard 1021 * against this. 1022 * <p> 1023 * Input: Nothing. 1024 * <p> 1025 * Output: Nothing. 1026 */ 1027 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 1028 public static final String 1029 ACTION_SHOW_REGULATORY_INFO = "android.settings.SHOW_REGULATORY_INFO"; 1030 1031 /** 1032 * Activity Action: Show Device Name Settings. 1033 * <p> 1034 * In some cases, a matching Activity may not exist, so ensure you safeguard 1035 * against this. 1036 * 1037 * @hide 1038 */ 1039 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 1040 public static final String DEVICE_NAME_SETTINGS = "android.settings.DEVICE_NAME"; 1041 1042 /** 1043 * Activity Action: Show pairing settings. 1044 * <p> 1045 * In some cases, a matching Activity may not exist, so ensure you safeguard 1046 * against this. 1047 * 1048 * @hide 1049 */ 1050 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 1051 public static final String ACTION_PAIRING_SETTINGS = "android.settings.PAIRING_SETTINGS"; 1052 1053 /** 1054 * Activity Action: Show battery saver settings. 1055 * <p> 1056 * In some cases, a matching Activity may not exist, so ensure you safeguard 1057 * against this. 1058 */ 1059 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 1060 public static final String ACTION_BATTERY_SAVER_SETTINGS 1061 = "android.settings.BATTERY_SAVER_SETTINGS"; 1062 1063 /** 1064 * Activity Action: Modify Battery Saver mode setting using a voice command. 1065 * <p> 1066 * In some cases, a matching Activity may not exist, so ensure you safeguard against this. 1067 * <p> 1068 * This intent MUST be started using 1069 * {@link android.service.voice.VoiceInteractionSession#startVoiceActivity 1070 * startVoiceActivity}. 1071 * <p> 1072 * Note: The activity implementing this intent MUST verify that 1073 * {@link android.app.Activity#isVoiceInteraction isVoiceInteraction} returns true before 1074 * modifying the setting. 1075 * <p> 1076 * Input: To tell which state batter saver mode should be set to, add the 1077 * {@link #EXTRA_BATTERY_SAVER_MODE_ENABLED} extra to this Intent with the state specified. 1078 * If the extra is not included, no changes will be made. 1079 * <p> 1080 * Output: Nothing. 1081 */ 1082 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 1083 public static final String ACTION_VOICE_CONTROL_BATTERY_SAVER_MODE = 1084 "android.settings.VOICE_CONTROL_BATTERY_SAVER_MODE"; 1085 1086 /** 1087 * Activity Action: Show Home selection settings. If there are multiple activities 1088 * that can satisfy the {@link Intent#CATEGORY_HOME} intent, this screen allows you 1089 * to pick your preferred activity. 1090 */ 1091 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 1092 public static final String ACTION_HOME_SETTINGS 1093 = "android.settings.HOME_SETTINGS"; 1094 1095 /** 1096 * Activity Action: Show notification settings. 1097 * 1098 * @hide 1099 */ 1100 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 1101 public static final String ACTION_NOTIFICATION_SETTINGS 1102 = "android.settings.NOTIFICATION_SETTINGS"; 1103 1104 /** 1105 * Activity Action: Show notification settings for a single app. 1106 * 1107 * @hide 1108 */ 1109 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 1110 public static final String ACTION_APP_NOTIFICATION_SETTINGS 1111 = "android.settings.APP_NOTIFICATION_SETTINGS"; 1112 1113 /** 1114 * Activity Action: Show notification redaction settings. 1115 * 1116 * @hide 1117 */ 1118 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 1119 public static final String ACTION_APP_NOTIFICATION_REDACTION 1120 = "android.settings.ACTION_APP_NOTIFICATION_REDACTION"; 1121 1122 /** @hide */ public static final String EXTRA_APP_UID = "app_uid"; 1123 /** @hide */ public static final String EXTRA_APP_PACKAGE = "app_package"; 1124 1125 // End of Intent actions for Settings 1126 1127 /** 1128 * @hide - Private call() method on SettingsProvider to read from 'system' table. 1129 */ 1130 public static final String CALL_METHOD_GET_SYSTEM = "GET_system"; 1131 1132 /** 1133 * @hide - Private call() method on SettingsProvider to read from 'secure' table. 1134 */ 1135 public static final String CALL_METHOD_GET_SECURE = "GET_secure"; 1136 1137 /** 1138 * @hide - Private call() method on SettingsProvider to read from 'global' table. 1139 */ 1140 public static final String CALL_METHOD_GET_GLOBAL = "GET_global"; 1141 1142 /** 1143 * @hide - User handle argument extra to the fast-path call()-based requests 1144 */ 1145 public static final String CALL_METHOD_USER_KEY = "_user"; 1146 1147 /** @hide - Private call() method to write to 'system' table */ 1148 public static final String CALL_METHOD_PUT_SYSTEM = "PUT_system"; 1149 1150 /** @hide - Private call() method to write to 'secure' table */ 1151 public static final String CALL_METHOD_PUT_SECURE = "PUT_secure"; 1152 1153 /** @hide - Private call() method to write to 'global' table */ 1154 public static final String CALL_METHOD_PUT_GLOBAL= "PUT_global"; 1155 1156 /** 1157 * Activity Extra: Limit available options in launched activity based on the given authority. 1158 * <p> 1159 * This can be passed as an extra field in an Activity Intent with one or more syncable content 1160 * provider's authorities as a String[]. This field is used by some intents to alter the 1161 * behavior of the called activity. 1162 * <p> 1163 * Example: The {@link #ACTION_ADD_ACCOUNT} intent restricts the account types available based 1164 * on the authority given. 1165 */ 1166 public static final String EXTRA_AUTHORITIES = "authorities"; 1167 1168 /** 1169 * Activity Extra: Limit available options in launched activity based on the given account 1170 * types. 1171 * <p> 1172 * This can be passed as an extra field in an Activity Intent with one or more account types 1173 * as a String[]. This field is used by some intents to alter the behavior of the called 1174 * activity. 1175 * <p> 1176 * Example: The {@link #ACTION_ADD_ACCOUNT} intent restricts the account types to the specified 1177 * list. 1178 */ 1179 public static final String EXTRA_ACCOUNT_TYPES = "account_types"; 1180 1181 public static final String EXTRA_INPUT_METHOD_ID = "input_method_id"; 1182 1183 /** 1184 * Activity Extra: The device identifier to act upon. 1185 * <p> 1186 * This can be passed as an extra field in an Activity Intent with a single 1187 * InputDeviceIdentifier. This field is used by some activities to jump straight into the 1188 * settings for the given device. 1189 * <p> 1190 * Example: The {@link #ACTION_INPUT_METHOD_SETTINGS} intent opens the keyboard layout 1191 * dialog for the given device. 1192 * @hide 1193 */ 1194 public static final String EXTRA_INPUT_DEVICE_IDENTIFIER = "input_device_identifier"; 1195 1196 /** 1197 * Activity Extra: Enable or disable Airplane Mode. 1198 * <p> 1199 * This can be passed as an extra field to the {@link #ACTION_VOICE_CONTROL_AIRPLANE_MODE} 1200 * intent as a boolean to indicate if it should be enabled. 1201 */ 1202 public static final String EXTRA_AIRPLANE_MODE_ENABLED = "airplane_mode_enabled"; 1203 1204 /** 1205 * Activity Extra: Enable or disable Battery saver mode. 1206 * <p> 1207 * This can be passed as an extra field to the {@link #ACTION_VOICE_CONTROL_BATTERY_SAVER_MODE} 1208 * intent as a boolean to indicate if it should be enabled. 1209 */ 1210 public static final String EXTRA_BATTERY_SAVER_MODE_ENABLED = 1211 "android.settings.extra.battery_saver_mode_enabled"; 1212 1213 /** 1214 * Activity Extra: Enable or disable Do Not Disturb mode. 1215 * <p> 1216 * This can be passed as an extra field to the {@link #ACTION_VOICE_CONTROL_DO_NOT_DISTURB_MODE} 1217 * intent as a boolean to indicate if it should be enabled. 1218 */ 1219 public static final String EXTRA_DO_NOT_DISTURB_MODE_ENABLED = 1220 "android.settings.extra.do_not_disturb_mode_enabled"; 1221 1222 /** 1223 * Activity Extra: How many minutes to enable do not disturb mode for. 1224 * <p> 1225 * This can be passed as an extra field to the {@link #ACTION_VOICE_CONTROL_DO_NOT_DISTURB_MODE} 1226 * intent to indicate how long do not disturb mode should be enabled for. 1227 */ 1228 public static final String EXTRA_DO_NOT_DISTURB_MODE_MINUTES = 1229 "android.settings.extra.do_not_disturb_mode_minutes"; 1230 1231 private static final String JID_RESOURCE_PREFIX = "android"; 1232 1233 public static final String AUTHORITY = "settings"; 1234 1235 private static final String TAG = "Settings"; 1236 private static final boolean LOCAL_LOGV = false; 1237 1238 // Lock ensures that when enabling/disabling the master location switch, we don't end up 1239 // with a partial enable/disable state in multi-threaded situations. 1240 private static final Object mLocationSettingsLock = new Object(); 1241 1242 public static class SettingNotFoundException extends AndroidException { SettingNotFoundException(String msg)1243 public SettingNotFoundException(String msg) { 1244 super(msg); 1245 } 1246 } 1247 1248 /** 1249 * Common base for tables of name/value settings. 1250 */ 1251 public static class NameValueTable implements BaseColumns { 1252 public static final String NAME = "name"; 1253 public static final String VALUE = "value"; 1254 putString(ContentResolver resolver, Uri uri, String name, String value)1255 protected static boolean putString(ContentResolver resolver, Uri uri, 1256 String name, String value) { 1257 // The database will take care of replacing duplicates. 1258 try { 1259 ContentValues values = new ContentValues(); 1260 values.put(NAME, name); 1261 values.put(VALUE, value); 1262 resolver.insert(uri, values); 1263 return true; 1264 } catch (SQLException e) { 1265 Log.w(TAG, "Can't set key " + name + " in " + uri, e); 1266 return false; 1267 } 1268 } 1269 getUriFor(Uri uri, String name)1270 public static Uri getUriFor(Uri uri, String name) { 1271 return Uri.withAppendedPath(uri, name); 1272 } 1273 } 1274 1275 // Thread-safe. 1276 private static class NameValueCache { 1277 private final String mVersionSystemProperty; 1278 private final Uri mUri; 1279 1280 private static final String[] SELECT_VALUE = 1281 new String[] { Settings.NameValueTable.VALUE }; 1282 private static final String NAME_EQ_PLACEHOLDER = "name=?"; 1283 1284 // Must synchronize on 'this' to access mValues and mValuesVersion. 1285 private final HashMap<String, String> mValues = new HashMap<String, String>(); 1286 private long mValuesVersion = 0; 1287 1288 // Initially null; set lazily and held forever. Synchronized on 'this'. 1289 private IContentProvider mContentProvider = null; 1290 1291 // The method we'll call (or null, to not use) on the provider 1292 // for the fast path of retrieving settings. 1293 private final String mCallGetCommand; 1294 private final String mCallSetCommand; 1295 NameValueCache(String versionSystemProperty, Uri uri, String getCommand, String setCommand)1296 public NameValueCache(String versionSystemProperty, Uri uri, 1297 String getCommand, String setCommand) { 1298 mVersionSystemProperty = versionSystemProperty; 1299 mUri = uri; 1300 mCallGetCommand = getCommand; 1301 mCallSetCommand = setCommand; 1302 } 1303 lazyGetProvider(ContentResolver cr)1304 private IContentProvider lazyGetProvider(ContentResolver cr) { 1305 IContentProvider cp = null; 1306 synchronized (this) { 1307 cp = mContentProvider; 1308 if (cp == null) { 1309 cp = mContentProvider = cr.acquireProvider(mUri.getAuthority()); 1310 } 1311 } 1312 return cp; 1313 } 1314 putStringForUser(ContentResolver cr, String name, String value, final int userHandle)1315 public boolean putStringForUser(ContentResolver cr, String name, String value, 1316 final int userHandle) { 1317 try { 1318 Bundle arg = new Bundle(); 1319 arg.putString(Settings.NameValueTable.VALUE, value); 1320 arg.putInt(CALL_METHOD_USER_KEY, userHandle); 1321 IContentProvider cp = lazyGetProvider(cr); 1322 cp.call(cr.getPackageName(), mCallSetCommand, name, arg); 1323 } catch (RemoteException e) { 1324 Log.w(TAG, "Can't set key " + name + " in " + mUri, e); 1325 return false; 1326 } 1327 return true; 1328 } 1329 getStringForUser(ContentResolver cr, String name, final int userHandle)1330 public String getStringForUser(ContentResolver cr, String name, final int userHandle) { 1331 final boolean isSelf = (userHandle == UserHandle.myUserId()); 1332 if (isSelf) { 1333 long newValuesVersion = SystemProperties.getLong(mVersionSystemProperty, 0); 1334 1335 // Our own user's settings data uses a client-side cache 1336 synchronized (this) { 1337 if (mValuesVersion != newValuesVersion) { 1338 if (LOCAL_LOGV || false) { 1339 Log.v(TAG, "invalidate [" + mUri.getLastPathSegment() + "]: current " 1340 + newValuesVersion + " != cached " + mValuesVersion); 1341 } 1342 1343 mValues.clear(); 1344 mValuesVersion = newValuesVersion; 1345 } 1346 1347 if (mValues.containsKey(name)) { 1348 return mValues.get(name); // Could be null, that's OK -- negative caching 1349 } 1350 } 1351 } else { 1352 if (LOCAL_LOGV) Log.v(TAG, "get setting for user " + userHandle 1353 + " by user " + UserHandle.myUserId() + " so skipping cache"); 1354 } 1355 1356 IContentProvider cp = lazyGetProvider(cr); 1357 1358 // Try the fast path first, not using query(). If this 1359 // fails (alternate Settings provider that doesn't support 1360 // this interface?) then we fall back to the query/table 1361 // interface. 1362 if (mCallGetCommand != null) { 1363 try { 1364 Bundle args = null; 1365 if (!isSelf) { 1366 args = new Bundle(); 1367 args.putInt(CALL_METHOD_USER_KEY, userHandle); 1368 } 1369 Bundle b = cp.call(cr.getPackageName(), mCallGetCommand, name, args); 1370 if (b != null) { 1371 String value = b.getPairValue(); 1372 // Don't update our cache for reads of other users' data 1373 if (isSelf) { 1374 synchronized (this) { 1375 mValues.put(name, value); 1376 } 1377 } else { 1378 if (LOCAL_LOGV) Log.i(TAG, "call-query of user " + userHandle 1379 + " by " + UserHandle.myUserId() 1380 + " so not updating cache"); 1381 } 1382 return value; 1383 } 1384 // If the response Bundle is null, we fall through 1385 // to the query interface below. 1386 } catch (RemoteException e) { 1387 // Not supported by the remote side? Fall through 1388 // to query(). 1389 } 1390 } 1391 1392 Cursor c = null; 1393 try { 1394 c = cp.query(cr.getPackageName(), mUri, SELECT_VALUE, NAME_EQ_PLACEHOLDER, 1395 new String[]{name}, null, null); 1396 if (c == null) { 1397 Log.w(TAG, "Can't get key " + name + " from " + mUri); 1398 return null; 1399 } 1400 1401 String value = c.moveToNext() ? c.getString(0) : null; 1402 synchronized (this) { 1403 mValues.put(name, value); 1404 } 1405 if (LOCAL_LOGV) { 1406 Log.v(TAG, "cache miss [" + mUri.getLastPathSegment() + "]: " + 1407 name + " = " + (value == null ? "(null)" : value)); 1408 } 1409 return value; 1410 } catch (RemoteException e) { 1411 Log.w(TAG, "Can't get key " + name + " from " + mUri, e); 1412 return null; // Return null, but don't cache it. 1413 } finally { 1414 if (c != null) c.close(); 1415 } 1416 } 1417 } 1418 1419 /** 1420 * An app can use this method to check if it is currently allowed to draw on top of other 1421 * apps. In order to be allowed to do so, an app must first declare the 1422 * {@link android.Manifest.permission#SYSTEM_ALERT_WINDOW} permission in its manifest. If it 1423 * is currently disallowed, it can prompt the user to grant it this capability through a 1424 * management UI by sending an Intent with action 1425 * {@link android.provider.Settings#ACTION_MANAGE_OVERLAY_PERMISSION}. 1426 * 1427 * @param context A context 1428 * @return true if the calling app can draw on top of other apps, false otherwise. 1429 */ canDrawOverlays(Context context)1430 public static boolean canDrawOverlays(Context context) { 1431 int uid = Binder.getCallingUid(); 1432 return Settings.isCallingPackageAllowedToDrawOverlays(context, uid, Settings 1433 .getPackageNameForUid(context, uid), false); 1434 } 1435 1436 /** 1437 * An app can use this method to check if it is currently allowed to change the network 1438 * state. In order to be allowed to do so, an app must first declare either the 1439 * {@link android.Manifest.permission#CHANGE_NETWORK_STATE} or 1440 * {@link android.Manifest.permission#WRITE_SETTINGS} permission in its manifest. If it 1441 * is currently disallowed, it can prompt the user to grant it this capability through a 1442 * management UI by sending an Intent with action 1443 * {@link android.provider.Settings#ACTION_MANAGE_WRITE_SETTINGS}. 1444 * 1445 * @param context A context 1446 * @return true if the calling app can change the state of network, false otherwise. 1447 * @hide 1448 */ canChangeNetworkState(Context context)1449 public static boolean canChangeNetworkState(Context context) { 1450 int uid = Binder.getCallingUid(); 1451 return Settings.isCallingPackageAllowedToChangeNetworkState(context, uid, Settings 1452 .getPackageNameForUid(context, uid), false); 1453 } 1454 1455 /** 1456 * System settings, containing miscellaneous system preferences. This 1457 * table holds simple name/value pairs. There are convenience 1458 * functions for accessing individual settings entries. 1459 */ 1460 public static final class System extends NameValueTable { 1461 public static final String SYS_PROP_SETTING_VERSION = "sys.settings_system_version"; 1462 1463 /** @hide */ 1464 public static interface Validator { validate(String value)1465 public boolean validate(String value); 1466 } 1467 1468 /** 1469 * The content:// style URL for this table 1470 */ 1471 public static final Uri CONTENT_URI = 1472 Uri.parse("content://" + AUTHORITY + "/system"); 1473 1474 private static final NameValueCache sNameValueCache = new NameValueCache( 1475 SYS_PROP_SETTING_VERSION, 1476 CONTENT_URI, 1477 CALL_METHOD_GET_SYSTEM, 1478 CALL_METHOD_PUT_SYSTEM); 1479 1480 private static final HashSet<String> MOVED_TO_SECURE; 1481 static { 1482 MOVED_TO_SECURE = new HashSet<String>(30); 1483 MOVED_TO_SECURE.add(Secure.ANDROID_ID); 1484 MOVED_TO_SECURE.add(Secure.HTTP_PROXY); 1485 MOVED_TO_SECURE.add(Secure.LOCATION_PROVIDERS_ALLOWED); 1486 MOVED_TO_SECURE.add(Secure.LOCK_BIOMETRIC_WEAK_FLAGS); 1487 MOVED_TO_SECURE.add(Secure.LOCK_PATTERN_ENABLED); 1488 MOVED_TO_SECURE.add(Secure.LOCK_PATTERN_VISIBLE); 1489 MOVED_TO_SECURE.add(Secure.LOCK_PATTERN_TACTILE_FEEDBACK_ENABLED); 1490 MOVED_TO_SECURE.add(Secure.LOGGING_ID); 1491 MOVED_TO_SECURE.add(Secure.PARENTAL_CONTROL_ENABLED); 1492 MOVED_TO_SECURE.add(Secure.PARENTAL_CONTROL_LAST_UPDATE); 1493 MOVED_TO_SECURE.add(Secure.PARENTAL_CONTROL_REDIRECT_URL); 1494 MOVED_TO_SECURE.add(Secure.SETTINGS_CLASSNAME); 1495 MOVED_TO_SECURE.add(Secure.USE_GOOGLE_MAIL); 1496 MOVED_TO_SECURE.add(Secure.WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON); 1497 MOVED_TO_SECURE.add(Secure.WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY); 1498 MOVED_TO_SECURE.add(Secure.WIFI_NUM_OPEN_NETWORKS_KEPT); 1499 MOVED_TO_SECURE.add(Secure.WIFI_ON); 1500 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_ACCEPTABLE_PACKET_LOSS_PERCENTAGE); 1501 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_AP_COUNT); 1502 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_BACKGROUND_CHECK_DELAY_MS); 1503 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_BACKGROUND_CHECK_ENABLED); 1504 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_BACKGROUND_CHECK_TIMEOUT_MS); 1505 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_INITIAL_IGNORED_PING_COUNT); 1506 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_MAX_AP_CHECKS); 1507 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_ON); 1508 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_PING_COUNT); 1509 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_PING_DELAY_MS); 1510 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_PING_TIMEOUT_MS); 1511 1512 // At one time in System, then Global, but now back in Secure 1513 MOVED_TO_SECURE.add(Secure.INSTALL_NON_MARKET_APPS); 1514 } 1515 1516 private static final HashSet<String> MOVED_TO_GLOBAL; 1517 private static final HashSet<String> MOVED_TO_SECURE_THEN_GLOBAL; 1518 static { 1519 MOVED_TO_GLOBAL = new HashSet<String>(); 1520 MOVED_TO_SECURE_THEN_GLOBAL = new HashSet<String>(); 1521 1522 // these were originally in system but migrated to secure in the past, 1523 // so are duplicated in the Secure.* namespace 1524 MOVED_TO_SECURE_THEN_GLOBAL.add(Global.ADB_ENABLED); 1525 MOVED_TO_SECURE_THEN_GLOBAL.add(Global.BLUETOOTH_ON); 1526 MOVED_TO_SECURE_THEN_GLOBAL.add(Global.DATA_ROAMING); 1527 MOVED_TO_SECURE_THEN_GLOBAL.add(Global.DEVICE_PROVISIONED); 1528 MOVED_TO_SECURE_THEN_GLOBAL.add(Global.USB_MASS_STORAGE_ENABLED); 1529 MOVED_TO_SECURE_THEN_GLOBAL.add(Global.HTTP_PROXY); 1530 1531 // these are moving directly from system to global 1532 MOVED_TO_GLOBAL.add(Settings.Global.AIRPLANE_MODE_ON); 1533 MOVED_TO_GLOBAL.add(Settings.Global.AIRPLANE_MODE_RADIOS); 1534 MOVED_TO_GLOBAL.add(Settings.Global.AIRPLANE_MODE_TOGGLEABLE_RADIOS); 1535 MOVED_TO_GLOBAL.add(Settings.Global.AUTO_TIME); 1536 MOVED_TO_GLOBAL.add(Settings.Global.AUTO_TIME_ZONE); 1537 MOVED_TO_GLOBAL.add(Settings.Global.CAR_DOCK_SOUND); 1538 MOVED_TO_GLOBAL.add(Settings.Global.CAR_UNDOCK_SOUND); 1539 MOVED_TO_GLOBAL.add(Settings.Global.DESK_DOCK_SOUND); 1540 MOVED_TO_GLOBAL.add(Settings.Global.DESK_UNDOCK_SOUND); 1541 MOVED_TO_GLOBAL.add(Settings.Global.DOCK_SOUNDS_ENABLED); 1542 MOVED_TO_GLOBAL.add(Settings.Global.LOCK_SOUND); 1543 MOVED_TO_GLOBAL.add(Settings.Global.UNLOCK_SOUND); 1544 MOVED_TO_GLOBAL.add(Settings.Global.LOW_BATTERY_SOUND); 1545 MOVED_TO_GLOBAL.add(Settings.Global.POWER_SOUNDS_ENABLED); 1546 MOVED_TO_GLOBAL.add(Settings.Global.STAY_ON_WHILE_PLUGGED_IN); 1547 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_SLEEP_POLICY); 1548 MOVED_TO_GLOBAL.add(Settings.Global.MODE_RINGER); 1549 MOVED_TO_GLOBAL.add(Settings.Global.WINDOW_ANIMATION_SCALE); 1550 MOVED_TO_GLOBAL.add(Settings.Global.TRANSITION_ANIMATION_SCALE); 1551 MOVED_TO_GLOBAL.add(Settings.Global.ANIMATOR_DURATION_SCALE); 1552 MOVED_TO_GLOBAL.add(Settings.Global.FANCY_IME_ANIMATIONS); 1553 MOVED_TO_GLOBAL.add(Settings.Global.COMPATIBILITY_MODE); 1554 MOVED_TO_GLOBAL.add(Settings.Global.EMERGENCY_TONE); 1555 MOVED_TO_GLOBAL.add(Settings.Global.CALL_AUTO_RETRY); 1556 MOVED_TO_GLOBAL.add(Settings.Global.DEBUG_APP); 1557 MOVED_TO_GLOBAL.add(Settings.Global.WAIT_FOR_DEBUGGER); 1558 MOVED_TO_GLOBAL.add(Settings.Global.SHOW_PROCESSES); 1559 MOVED_TO_GLOBAL.add(Settings.Global.ALWAYS_FINISH_ACTIVITIES); 1560 MOVED_TO_GLOBAL.add(Settings.Global.TZINFO_UPDATE_CONTENT_URL); 1561 MOVED_TO_GLOBAL.add(Settings.Global.TZINFO_UPDATE_METADATA_URL); 1562 MOVED_TO_GLOBAL.add(Settings.Global.SELINUX_UPDATE_CONTENT_URL); 1563 MOVED_TO_GLOBAL.add(Settings.Global.SELINUX_UPDATE_METADATA_URL); 1564 MOVED_TO_GLOBAL.add(Settings.Global.SMS_SHORT_CODES_UPDATE_CONTENT_URL); 1565 MOVED_TO_GLOBAL.add(Settings.Global.SMS_SHORT_CODES_UPDATE_METADATA_URL); 1566 MOVED_TO_GLOBAL.add(Settings.Global.CERT_PIN_UPDATE_CONTENT_URL); 1567 MOVED_TO_GLOBAL.add(Settings.Global.CERT_PIN_UPDATE_METADATA_URL); 1568 } 1569 1570 private static final Validator sBooleanValidator = 1571 new DiscreteValueValidator(new String[] {"0", "1"}); 1572 1573 private static final Validator sNonNegativeIntegerValidator = new Validator() { 1574 @Override 1575 public boolean validate(String value) { 1576 try { 1577 return Integer.parseInt(value) >= 0; 1578 } catch (NumberFormatException e) { 1579 return false; 1580 } 1581 } 1582 }; 1583 1584 private static final Validator sUriValidator = new Validator() { 1585 @Override 1586 public boolean validate(String value) { 1587 try { 1588 Uri.decode(value); 1589 return true; 1590 } catch (IllegalArgumentException e) { 1591 return false; 1592 } 1593 } 1594 }; 1595 1596 private static final Validator sLenientIpAddressValidator = new Validator() { 1597 private static final int MAX_IPV6_LENGTH = 45; 1598 1599 @Override 1600 public boolean validate(String value) { 1601 return value.length() <= MAX_IPV6_LENGTH; 1602 } 1603 }; 1604 1605 /** @hide */ getMovedToGlobalSettings(Set<String> outKeySet)1606 public static void getMovedToGlobalSettings(Set<String> outKeySet) { 1607 outKeySet.addAll(MOVED_TO_GLOBAL); 1608 outKeySet.addAll(MOVED_TO_SECURE_THEN_GLOBAL); 1609 } 1610 1611 /** @hide */ getMovedToSecureSettings(Set<String> outKeySet)1612 public static void getMovedToSecureSettings(Set<String> outKeySet) { 1613 outKeySet.addAll(MOVED_TO_SECURE); 1614 } 1615 1616 /** @hide */ getNonLegacyMovedKeys(HashSet<String> outKeySet)1617 public static void getNonLegacyMovedKeys(HashSet<String> outKeySet) { 1618 outKeySet.addAll(MOVED_TO_GLOBAL); 1619 } 1620 1621 /** 1622 * Look up a name in the database. 1623 * @param resolver to access the database with 1624 * @param name to look up in the table 1625 * @return the corresponding value, or null if not present 1626 */ getString(ContentResolver resolver, String name)1627 public static String getString(ContentResolver resolver, String name) { 1628 return getStringForUser(resolver, name, UserHandle.myUserId()); 1629 } 1630 1631 /** @hide */ getStringForUser(ContentResolver resolver, String name, int userHandle)1632 public static String getStringForUser(ContentResolver resolver, String name, 1633 int userHandle) { 1634 if (MOVED_TO_SECURE.contains(name)) { 1635 Log.w(TAG, "Setting " + name + " has moved from android.provider.Settings.System" 1636 + " to android.provider.Settings.Secure, returning read-only value."); 1637 return Secure.getStringForUser(resolver, name, userHandle); 1638 } 1639 if (MOVED_TO_GLOBAL.contains(name) || MOVED_TO_SECURE_THEN_GLOBAL.contains(name)) { 1640 Log.w(TAG, "Setting " + name + " has moved from android.provider.Settings.System" 1641 + " to android.provider.Settings.Global, returning read-only value."); 1642 return Global.getStringForUser(resolver, name, userHandle); 1643 } 1644 return sNameValueCache.getStringForUser(resolver, name, userHandle); 1645 } 1646 1647 /** 1648 * Store a name/value pair into the database. 1649 * @param resolver to access the database with 1650 * @param name to store 1651 * @param value to associate with the name 1652 * @return true if the value was set, false on database errors 1653 */ putString(ContentResolver resolver, String name, String value)1654 public static boolean putString(ContentResolver resolver, String name, String value) { 1655 return putStringForUser(resolver, name, value, UserHandle.myUserId()); 1656 } 1657 1658 /** @hide */ putStringForUser(ContentResolver resolver, String name, String value, int userHandle)1659 public static boolean putStringForUser(ContentResolver resolver, String name, String value, 1660 int userHandle) { 1661 if (MOVED_TO_SECURE.contains(name)) { 1662 Log.w(TAG, "Setting " + name + " has moved from android.provider.Settings.System" 1663 + " to android.provider.Settings.Secure, value is unchanged."); 1664 return false; 1665 } 1666 if (MOVED_TO_GLOBAL.contains(name) || MOVED_TO_SECURE_THEN_GLOBAL.contains(name)) { 1667 Log.w(TAG, "Setting " + name + " has moved from android.provider.Settings.System" 1668 + " to android.provider.Settings.Global, value is unchanged."); 1669 return false; 1670 } 1671 return sNameValueCache.putStringForUser(resolver, name, value, userHandle); 1672 } 1673 1674 /** 1675 * Construct the content URI for a particular name/value pair, 1676 * useful for monitoring changes with a ContentObserver. 1677 * @param name to look up in the table 1678 * @return the corresponding content URI, or null if not present 1679 */ getUriFor(String name)1680 public static Uri getUriFor(String name) { 1681 if (MOVED_TO_SECURE.contains(name)) { 1682 Log.w(TAG, "Setting " + name + " has moved from android.provider.Settings.System" 1683 + " to android.provider.Settings.Secure, returning Secure URI."); 1684 return Secure.getUriFor(Secure.CONTENT_URI, name); 1685 } 1686 if (MOVED_TO_GLOBAL.contains(name) || MOVED_TO_SECURE_THEN_GLOBAL.contains(name)) { 1687 Log.w(TAG, "Setting " + name + " has moved from android.provider.Settings.System" 1688 + " to android.provider.Settings.Global, returning read-only global URI."); 1689 return Global.getUriFor(Global.CONTENT_URI, name); 1690 } 1691 return getUriFor(CONTENT_URI, name); 1692 } 1693 1694 /** 1695 * Convenience function for retrieving a single system settings value 1696 * as an integer. Note that internally setting values are always 1697 * stored as strings; this function converts the string to an integer 1698 * for you. The default value will be returned if the setting is 1699 * not defined or not an integer. 1700 * 1701 * @param cr The ContentResolver to access. 1702 * @param name The name of the setting to retrieve. 1703 * @param def Value to return if the setting is not defined. 1704 * 1705 * @return The setting's current value, or 'def' if it is not defined 1706 * or not a valid integer. 1707 */ getInt(ContentResolver cr, String name, int def)1708 public static int getInt(ContentResolver cr, String name, int def) { 1709 return getIntForUser(cr, name, def, UserHandle.myUserId()); 1710 } 1711 1712 /** @hide */ getIntForUser(ContentResolver cr, String name, int def, int userHandle)1713 public static int getIntForUser(ContentResolver cr, String name, int def, int userHandle) { 1714 String v = getStringForUser(cr, name, userHandle); 1715 try { 1716 return v != null ? Integer.parseInt(v) : def; 1717 } catch (NumberFormatException e) { 1718 return def; 1719 } 1720 } 1721 1722 /** 1723 * Convenience function for retrieving a single system settings value 1724 * as an integer. Note that internally setting values are always 1725 * stored as strings; this function converts the string to an integer 1726 * for you. 1727 * <p> 1728 * This version does not take a default value. If the setting has not 1729 * been set, or the string value is not a number, 1730 * it throws {@link SettingNotFoundException}. 1731 * 1732 * @param cr The ContentResolver to access. 1733 * @param name The name of the setting to retrieve. 1734 * 1735 * @throws SettingNotFoundException Thrown if a setting by the given 1736 * name can't be found or the setting value is not an integer. 1737 * 1738 * @return The setting's current value. 1739 */ getInt(ContentResolver cr, String name)1740 public static int getInt(ContentResolver cr, String name) 1741 throws SettingNotFoundException { 1742 return getIntForUser(cr, name, UserHandle.myUserId()); 1743 } 1744 1745 /** @hide */ getIntForUser(ContentResolver cr, String name, int userHandle)1746 public static int getIntForUser(ContentResolver cr, String name, int userHandle) 1747 throws SettingNotFoundException { 1748 String v = getStringForUser(cr, name, userHandle); 1749 try { 1750 return Integer.parseInt(v); 1751 } catch (NumberFormatException e) { 1752 throw new SettingNotFoundException(name); 1753 } 1754 } 1755 1756 /** 1757 * Convenience function for updating a single settings value as an 1758 * integer. This will either create a new entry in the table if the 1759 * given name does not exist, or modify the value of the existing row 1760 * with that name. Note that internally setting values are always 1761 * stored as strings, so this function converts the given value to a 1762 * string before storing it. 1763 * 1764 * @param cr The ContentResolver to access. 1765 * @param name The name of the setting to modify. 1766 * @param value The new value for the setting. 1767 * @return true if the value was set, false on database errors 1768 */ putInt(ContentResolver cr, String name, int value)1769 public static boolean putInt(ContentResolver cr, String name, int value) { 1770 return putIntForUser(cr, name, value, UserHandle.myUserId()); 1771 } 1772 1773 /** @hide */ putIntForUser(ContentResolver cr, String name, int value, int userHandle)1774 public static boolean putIntForUser(ContentResolver cr, String name, int value, 1775 int userHandle) { 1776 return putStringForUser(cr, name, Integer.toString(value), userHandle); 1777 } 1778 1779 /** 1780 * Convenience function for retrieving a single system settings value 1781 * as a {@code long}. Note that internally setting values are always 1782 * stored as strings; this function converts the string to a {@code long} 1783 * for you. The default value will be returned if the setting is 1784 * not defined or not a {@code long}. 1785 * 1786 * @param cr The ContentResolver to access. 1787 * @param name The name of the setting to retrieve. 1788 * @param def Value to return if the setting is not defined. 1789 * 1790 * @return The setting's current value, or 'def' if it is not defined 1791 * or not a valid {@code long}. 1792 */ getLong(ContentResolver cr, String name, long def)1793 public static long getLong(ContentResolver cr, String name, long def) { 1794 return getLongForUser(cr, name, def, UserHandle.myUserId()); 1795 } 1796 1797 /** @hide */ getLongForUser(ContentResolver cr, String name, long def, int userHandle)1798 public static long getLongForUser(ContentResolver cr, String name, long def, 1799 int userHandle) { 1800 String valString = getStringForUser(cr, name, userHandle); 1801 long value; 1802 try { 1803 value = valString != null ? Long.parseLong(valString) : def; 1804 } catch (NumberFormatException e) { 1805 value = def; 1806 } 1807 return value; 1808 } 1809 1810 /** 1811 * Convenience function for retrieving a single system settings value 1812 * as a {@code long}. Note that internally setting values are always 1813 * stored as strings; this function converts the string to a {@code long} 1814 * for you. 1815 * <p> 1816 * This version does not take a default value. If the setting has not 1817 * been set, or the string value is not a number, 1818 * it throws {@link SettingNotFoundException}. 1819 * 1820 * @param cr The ContentResolver to access. 1821 * @param name The name of the setting to retrieve. 1822 * 1823 * @return The setting's current value. 1824 * @throws SettingNotFoundException Thrown if a setting by the given 1825 * name can't be found or the setting value is not an integer. 1826 */ getLong(ContentResolver cr, String name)1827 public static long getLong(ContentResolver cr, String name) 1828 throws SettingNotFoundException { 1829 return getLongForUser(cr, name, UserHandle.myUserId()); 1830 } 1831 1832 /** @hide */ getLongForUser(ContentResolver cr, String name, int userHandle)1833 public static long getLongForUser(ContentResolver cr, String name, int userHandle) 1834 throws SettingNotFoundException { 1835 String valString = getStringForUser(cr, name, userHandle); 1836 try { 1837 return Long.parseLong(valString); 1838 } catch (NumberFormatException e) { 1839 throw new SettingNotFoundException(name); 1840 } 1841 } 1842 1843 /** 1844 * Convenience function for updating a single settings value as a long 1845 * integer. This will either create a new entry in the table if the 1846 * given name does not exist, or modify the value of the existing row 1847 * with that name. Note that internally setting values are always 1848 * stored as strings, so this function converts the given value to a 1849 * string before storing it. 1850 * 1851 * @param cr The ContentResolver to access. 1852 * @param name The name of the setting to modify. 1853 * @param value The new value for the setting. 1854 * @return true if the value was set, false on database errors 1855 */ putLong(ContentResolver cr, String name, long value)1856 public static boolean putLong(ContentResolver cr, String name, long value) { 1857 return putLongForUser(cr, name, value, UserHandle.myUserId()); 1858 } 1859 1860 /** @hide */ putLongForUser(ContentResolver cr, String name, long value, int userHandle)1861 public static boolean putLongForUser(ContentResolver cr, String name, long value, 1862 int userHandle) { 1863 return putStringForUser(cr, name, Long.toString(value), userHandle); 1864 } 1865 1866 /** 1867 * Convenience function for retrieving a single system settings value 1868 * as a floating point number. Note that internally setting values are 1869 * always stored as strings; this function converts the string to an 1870 * float for you. The default value will be returned if the setting 1871 * is not defined or not a valid float. 1872 * 1873 * @param cr The ContentResolver to access. 1874 * @param name The name of the setting to retrieve. 1875 * @param def Value to return if the setting is not defined. 1876 * 1877 * @return The setting's current value, or 'def' if it is not defined 1878 * or not a valid float. 1879 */ getFloat(ContentResolver cr, String name, float def)1880 public static float getFloat(ContentResolver cr, String name, float def) { 1881 return getFloatForUser(cr, name, def, UserHandle.myUserId()); 1882 } 1883 1884 /** @hide */ getFloatForUser(ContentResolver cr, String name, float def, int userHandle)1885 public static float getFloatForUser(ContentResolver cr, String name, float def, 1886 int userHandle) { 1887 String v = getStringForUser(cr, name, userHandle); 1888 try { 1889 return v != null ? Float.parseFloat(v) : def; 1890 } catch (NumberFormatException e) { 1891 return def; 1892 } 1893 } 1894 1895 /** 1896 * Convenience function for retrieving a single system settings value 1897 * as a float. Note that internally setting values are always 1898 * stored as strings; this function converts the string to a float 1899 * for you. 1900 * <p> 1901 * This version does not take a default value. If the setting has not 1902 * been set, or the string value is not a number, 1903 * it throws {@link SettingNotFoundException}. 1904 * 1905 * @param cr The ContentResolver to access. 1906 * @param name The name of the setting to retrieve. 1907 * 1908 * @throws SettingNotFoundException Thrown if a setting by the given 1909 * name can't be found or the setting value is not a float. 1910 * 1911 * @return The setting's current value. 1912 */ getFloat(ContentResolver cr, String name)1913 public static float getFloat(ContentResolver cr, String name) 1914 throws SettingNotFoundException { 1915 return getFloatForUser(cr, name, UserHandle.myUserId()); 1916 } 1917 1918 /** @hide */ getFloatForUser(ContentResolver cr, String name, int userHandle)1919 public static float getFloatForUser(ContentResolver cr, String name, int userHandle) 1920 throws SettingNotFoundException { 1921 String v = getStringForUser(cr, name, userHandle); 1922 if (v == null) { 1923 throw new SettingNotFoundException(name); 1924 } 1925 try { 1926 return Float.parseFloat(v); 1927 } catch (NumberFormatException e) { 1928 throw new SettingNotFoundException(name); 1929 } 1930 } 1931 1932 /** 1933 * Convenience function for updating a single settings value as a 1934 * floating point number. This will either create a new entry in the 1935 * table if the given name does not exist, or modify the value of the 1936 * existing row with that name. Note that internally setting values 1937 * are always stored as strings, so this function converts the given 1938 * value to a string before storing it. 1939 * 1940 * @param cr The ContentResolver to access. 1941 * @param name The name of the setting to modify. 1942 * @param value The new value for the setting. 1943 * @return true if the value was set, false on database errors 1944 */ putFloat(ContentResolver cr, String name, float value)1945 public static boolean putFloat(ContentResolver cr, String name, float value) { 1946 return putFloatForUser(cr, name, value, UserHandle.myUserId()); 1947 } 1948 1949 /** @hide */ putFloatForUser(ContentResolver cr, String name, float value, int userHandle)1950 public static boolean putFloatForUser(ContentResolver cr, String name, float value, 1951 int userHandle) { 1952 return putStringForUser(cr, name, Float.toString(value), userHandle); 1953 } 1954 1955 /** 1956 * Convenience function to read all of the current 1957 * configuration-related settings into a 1958 * {@link Configuration} object. 1959 * 1960 * @param cr The ContentResolver to access. 1961 * @param outConfig Where to place the configuration settings. 1962 */ getConfiguration(ContentResolver cr, Configuration outConfig)1963 public static void getConfiguration(ContentResolver cr, Configuration outConfig) { 1964 getConfigurationForUser(cr, outConfig, UserHandle.myUserId()); 1965 } 1966 1967 /** @hide */ getConfigurationForUser(ContentResolver cr, Configuration outConfig, int userHandle)1968 public static void getConfigurationForUser(ContentResolver cr, Configuration outConfig, 1969 int userHandle) { 1970 outConfig.fontScale = Settings.System.getFloatForUser( 1971 cr, FONT_SCALE, outConfig.fontScale, userHandle); 1972 if (outConfig.fontScale < 0) { 1973 outConfig.fontScale = 1; 1974 } 1975 } 1976 1977 /** 1978 * @hide Erase the fields in the Configuration that should be applied 1979 * by the settings. 1980 */ clearConfiguration(Configuration inoutConfig)1981 public static void clearConfiguration(Configuration inoutConfig) { 1982 inoutConfig.fontScale = 0; 1983 } 1984 1985 /** 1986 * Convenience function to write a batch of configuration-related 1987 * settings from a {@link Configuration} object. 1988 * 1989 * @param cr The ContentResolver to access. 1990 * @param config The settings to write. 1991 * @return true if the values were set, false on database errors 1992 */ putConfiguration(ContentResolver cr, Configuration config)1993 public static boolean putConfiguration(ContentResolver cr, Configuration config) { 1994 return putConfigurationForUser(cr, config, UserHandle.myUserId()); 1995 } 1996 1997 /** @hide */ putConfigurationForUser(ContentResolver cr, Configuration config, int userHandle)1998 public static boolean putConfigurationForUser(ContentResolver cr, Configuration config, 1999 int userHandle) { 2000 return Settings.System.putFloatForUser(cr, FONT_SCALE, config.fontScale, userHandle); 2001 } 2002 2003 /** @hide */ hasInterestingConfigurationChanges(int changes)2004 public static boolean hasInterestingConfigurationChanges(int changes) { 2005 return (changes&ActivityInfo.CONFIG_FONT_SCALE) != 0; 2006 } 2007 2008 /** @deprecated - Do not use */ 2009 @Deprecated getShowGTalkServiceStatus(ContentResolver cr)2010 public static boolean getShowGTalkServiceStatus(ContentResolver cr) { 2011 return getShowGTalkServiceStatusForUser(cr, UserHandle.myUserId()); 2012 } 2013 2014 /** 2015 * @hide 2016 * @deprecated - Do not use 2017 */ getShowGTalkServiceStatusForUser(ContentResolver cr, int userHandle)2018 public static boolean getShowGTalkServiceStatusForUser(ContentResolver cr, 2019 int userHandle) { 2020 return getIntForUser(cr, SHOW_GTALK_SERVICE_STATUS, 0, userHandle) != 0; 2021 } 2022 2023 /** @deprecated - Do not use */ 2024 @Deprecated setShowGTalkServiceStatus(ContentResolver cr, boolean flag)2025 public static void setShowGTalkServiceStatus(ContentResolver cr, boolean flag) { 2026 setShowGTalkServiceStatusForUser(cr, flag, UserHandle.myUserId()); 2027 } 2028 2029 /** 2030 * @hide 2031 * @deprecated - Do not use 2032 */ 2033 @Deprecated setShowGTalkServiceStatusForUser(ContentResolver cr, boolean flag, int userHandle)2034 public static void setShowGTalkServiceStatusForUser(ContentResolver cr, boolean flag, 2035 int userHandle) { 2036 putIntForUser(cr, SHOW_GTALK_SERVICE_STATUS, flag ? 1 : 0, userHandle); 2037 } 2038 2039 private static final class DiscreteValueValidator implements Validator { 2040 private final String[] mValues; 2041 DiscreteValueValidator(String[] values)2042 public DiscreteValueValidator(String[] values) { 2043 mValues = values; 2044 } 2045 2046 @Override validate(String value)2047 public boolean validate(String value) { 2048 return ArrayUtils.contains(mValues, value); 2049 } 2050 } 2051 2052 private static final class InclusiveIntegerRangeValidator implements Validator { 2053 private final int mMin; 2054 private final int mMax; 2055 InclusiveIntegerRangeValidator(int min, int max)2056 public InclusiveIntegerRangeValidator(int min, int max) { 2057 mMin = min; 2058 mMax = max; 2059 } 2060 2061 @Override validate(String value)2062 public boolean validate(String value) { 2063 try { 2064 final int intValue = Integer.parseInt(value); 2065 return intValue >= mMin && intValue <= mMax; 2066 } catch (NumberFormatException e) { 2067 return false; 2068 } 2069 } 2070 } 2071 2072 private static final class InclusiveFloatRangeValidator implements Validator { 2073 private final float mMin; 2074 private final float mMax; 2075 InclusiveFloatRangeValidator(float min, float max)2076 public InclusiveFloatRangeValidator(float min, float max) { 2077 mMin = min; 2078 mMax = max; 2079 } 2080 2081 @Override validate(String value)2082 public boolean validate(String value) { 2083 try { 2084 final float floatValue = Float.parseFloat(value); 2085 return floatValue >= mMin && floatValue <= mMax; 2086 } catch (NumberFormatException e) { 2087 return false; 2088 } 2089 } 2090 } 2091 2092 /** 2093 * @deprecated Use {@link android.provider.Settings.Global#STAY_ON_WHILE_PLUGGED_IN} instead 2094 */ 2095 @Deprecated 2096 public static final String STAY_ON_WHILE_PLUGGED_IN = Global.STAY_ON_WHILE_PLUGGED_IN; 2097 2098 /** 2099 * What happens when the user presses the end call button if they're not 2100 * on a call.<br/> 2101 * <b>Values:</b><br/> 2102 * 0 - The end button does nothing.<br/> 2103 * 1 - The end button goes to the home screen.<br/> 2104 * 2 - The end button puts the device to sleep and locks the keyguard.<br/> 2105 * 3 - The end button goes to the home screen. If the user is already on the 2106 * home screen, it puts the device to sleep. 2107 */ 2108 public static final String END_BUTTON_BEHAVIOR = "end_button_behavior"; 2109 2110 private static final Validator END_BUTTON_BEHAVIOR_VALIDATOR = 2111 new InclusiveIntegerRangeValidator(0, 3); 2112 2113 /** 2114 * END_BUTTON_BEHAVIOR value for "go home". 2115 * @hide 2116 */ 2117 public static final int END_BUTTON_BEHAVIOR_HOME = 0x1; 2118 2119 /** 2120 * END_BUTTON_BEHAVIOR value for "go to sleep". 2121 * @hide 2122 */ 2123 public static final int END_BUTTON_BEHAVIOR_SLEEP = 0x2; 2124 2125 /** 2126 * END_BUTTON_BEHAVIOR default value. 2127 * @hide 2128 */ 2129 public static final int END_BUTTON_BEHAVIOR_DEFAULT = END_BUTTON_BEHAVIOR_SLEEP; 2130 2131 /** 2132 * Is advanced settings mode turned on. 0 == no, 1 == yes 2133 * @hide 2134 */ 2135 public static final String ADVANCED_SETTINGS = "advanced_settings"; 2136 2137 private static final Validator ADVANCED_SETTINGS_VALIDATOR = sBooleanValidator; 2138 2139 /** 2140 * ADVANCED_SETTINGS default value. 2141 * @hide 2142 */ 2143 public static final int ADVANCED_SETTINGS_DEFAULT = 0; 2144 2145 /** 2146 * @deprecated Use {@link android.provider.Settings.Global#AIRPLANE_MODE_ON} instead 2147 */ 2148 @Deprecated 2149 public static final String AIRPLANE_MODE_ON = Global.AIRPLANE_MODE_ON; 2150 2151 /** 2152 * @deprecated Use {@link android.provider.Settings.Global#RADIO_BLUETOOTH} instead 2153 */ 2154 @Deprecated 2155 public static final String RADIO_BLUETOOTH = Global.RADIO_BLUETOOTH; 2156 2157 /** 2158 * @deprecated Use {@link android.provider.Settings.Global#RADIO_WIFI} instead 2159 */ 2160 @Deprecated 2161 public static final String RADIO_WIFI = Global.RADIO_WIFI; 2162 2163 /** 2164 * @deprecated Use {@link android.provider.Settings.Global#RADIO_WIMAX} instead 2165 * {@hide} 2166 */ 2167 @Deprecated 2168 public static final String RADIO_WIMAX = Global.RADIO_WIMAX; 2169 2170 /** 2171 * @deprecated Use {@link android.provider.Settings.Global#RADIO_CELL} instead 2172 */ 2173 @Deprecated 2174 public static final String RADIO_CELL = Global.RADIO_CELL; 2175 2176 /** 2177 * @deprecated Use {@link android.provider.Settings.Global#RADIO_NFC} instead 2178 */ 2179 @Deprecated 2180 public static final String RADIO_NFC = Global.RADIO_NFC; 2181 2182 /** 2183 * @deprecated Use {@link android.provider.Settings.Global#AIRPLANE_MODE_RADIOS} instead 2184 */ 2185 @Deprecated 2186 public static final String AIRPLANE_MODE_RADIOS = Global.AIRPLANE_MODE_RADIOS; 2187 2188 /** 2189 * @deprecated Use {@link android.provider.Settings.Global#AIRPLANE_MODE_TOGGLEABLE_RADIOS} instead 2190 * 2191 * {@hide} 2192 */ 2193 @Deprecated 2194 public static final String AIRPLANE_MODE_TOGGLEABLE_RADIOS = 2195 Global.AIRPLANE_MODE_TOGGLEABLE_RADIOS; 2196 2197 /** 2198 * @deprecated Use {@link android.provider.Settings.Global#WIFI_SLEEP_POLICY} instead 2199 */ 2200 @Deprecated 2201 public static final String WIFI_SLEEP_POLICY = Global.WIFI_SLEEP_POLICY; 2202 2203 /** 2204 * @deprecated Use {@link android.provider.Settings.Global#WIFI_SLEEP_POLICY_DEFAULT} instead 2205 */ 2206 @Deprecated 2207 public static final int WIFI_SLEEP_POLICY_DEFAULT = Global.WIFI_SLEEP_POLICY_DEFAULT; 2208 2209 /** 2210 * @deprecated Use {@link android.provider.Settings.Global#WIFI_SLEEP_POLICY_NEVER_WHILE_PLUGGED} instead 2211 */ 2212 @Deprecated 2213 public static final int WIFI_SLEEP_POLICY_NEVER_WHILE_PLUGGED = 2214 Global.WIFI_SLEEP_POLICY_NEVER_WHILE_PLUGGED; 2215 2216 /** 2217 * @deprecated Use {@link android.provider.Settings.Global#WIFI_SLEEP_POLICY_NEVER} instead 2218 */ 2219 @Deprecated 2220 public static final int WIFI_SLEEP_POLICY_NEVER = Global.WIFI_SLEEP_POLICY_NEVER; 2221 2222 /** 2223 * @deprecated Use {@link android.provider.Settings.Global#MODE_RINGER} instead 2224 */ 2225 @Deprecated 2226 public static final String MODE_RINGER = Global.MODE_RINGER; 2227 2228 /** 2229 * Whether to use static IP and other static network attributes. 2230 * <p> 2231 * Set to 1 for true and 0 for false. 2232 * 2233 * @deprecated Use {@link WifiManager} instead 2234 */ 2235 @Deprecated 2236 public static final String WIFI_USE_STATIC_IP = "wifi_use_static_ip"; 2237 2238 private static final Validator WIFI_USE_STATIC_IP_VALIDATOR = sBooleanValidator; 2239 2240 /** 2241 * The static IP address. 2242 * <p> 2243 * Example: "192.168.1.51" 2244 * 2245 * @deprecated Use {@link WifiManager} instead 2246 */ 2247 @Deprecated 2248 public static final String WIFI_STATIC_IP = "wifi_static_ip"; 2249 2250 private static final Validator WIFI_STATIC_IP_VALIDATOR = sLenientIpAddressValidator; 2251 2252 /** 2253 * If using static IP, the gateway's IP address. 2254 * <p> 2255 * Example: "192.168.1.1" 2256 * 2257 * @deprecated Use {@link WifiManager} instead 2258 */ 2259 @Deprecated 2260 public static final String WIFI_STATIC_GATEWAY = "wifi_static_gateway"; 2261 2262 private static final Validator WIFI_STATIC_GATEWAY_VALIDATOR = sLenientIpAddressValidator; 2263 2264 /** 2265 * If using static IP, the net mask. 2266 * <p> 2267 * Example: "255.255.255.0" 2268 * 2269 * @deprecated Use {@link WifiManager} instead 2270 */ 2271 @Deprecated 2272 public static final String WIFI_STATIC_NETMASK = "wifi_static_netmask"; 2273 2274 private static final Validator WIFI_STATIC_NETMASK_VALIDATOR = sLenientIpAddressValidator; 2275 2276 /** 2277 * If using static IP, the primary DNS's IP address. 2278 * <p> 2279 * Example: "192.168.1.1" 2280 * 2281 * @deprecated Use {@link WifiManager} instead 2282 */ 2283 @Deprecated 2284 public static final String WIFI_STATIC_DNS1 = "wifi_static_dns1"; 2285 2286 private static final Validator WIFI_STATIC_DNS1_VALIDATOR = sLenientIpAddressValidator; 2287 2288 /** 2289 * If using static IP, the secondary DNS's IP address. 2290 * <p> 2291 * Example: "192.168.1.2" 2292 * 2293 * @deprecated Use {@link WifiManager} instead 2294 */ 2295 @Deprecated 2296 public static final String WIFI_STATIC_DNS2 = "wifi_static_dns2"; 2297 2298 private static final Validator WIFI_STATIC_DNS2_VALIDATOR = sLenientIpAddressValidator; 2299 2300 /** 2301 * Determines whether remote devices may discover and/or connect to 2302 * this device. 2303 * <P>Type: INT</P> 2304 * 2 -- discoverable and connectable 2305 * 1 -- connectable but not discoverable 2306 * 0 -- neither connectable nor discoverable 2307 */ 2308 public static final String BLUETOOTH_DISCOVERABILITY = 2309 "bluetooth_discoverability"; 2310 2311 private static final Validator BLUETOOTH_DISCOVERABILITY_VALIDATOR = 2312 new InclusiveIntegerRangeValidator(0, 2); 2313 2314 /** 2315 * Bluetooth discoverability timeout. If this value is nonzero, then 2316 * Bluetooth becomes discoverable for a certain number of seconds, 2317 * after which is becomes simply connectable. The value is in seconds. 2318 */ 2319 public static final String BLUETOOTH_DISCOVERABILITY_TIMEOUT = 2320 "bluetooth_discoverability_timeout"; 2321 2322 private static final Validator BLUETOOTH_DISCOVERABILITY_TIMEOUT_VALIDATOR = 2323 sNonNegativeIntegerValidator; 2324 2325 /** 2326 * @deprecated Use {@link android.provider.Settings.Secure#LOCK_PATTERN_ENABLED} 2327 * instead 2328 */ 2329 @Deprecated 2330 public static final String LOCK_PATTERN_ENABLED = Secure.LOCK_PATTERN_ENABLED; 2331 2332 /** 2333 * @deprecated Use {@link android.provider.Settings.Secure#LOCK_PATTERN_VISIBLE} 2334 * instead 2335 */ 2336 @Deprecated 2337 public static final String LOCK_PATTERN_VISIBLE = "lock_pattern_visible_pattern"; 2338 2339 /** 2340 * @deprecated Use 2341 * {@link android.provider.Settings.Secure#LOCK_PATTERN_TACTILE_FEEDBACK_ENABLED} 2342 * instead 2343 */ 2344 @Deprecated 2345 public static final String LOCK_PATTERN_TACTILE_FEEDBACK_ENABLED = 2346 "lock_pattern_tactile_feedback_enabled"; 2347 2348 /** 2349 * A formatted string of the next alarm that is set, or the empty string 2350 * if there is no alarm set. 2351 * 2352 * @deprecated Use {@link android.app.AlarmManager#getNextAlarmClock()}. 2353 */ 2354 @Deprecated 2355 public static final String NEXT_ALARM_FORMATTED = "next_alarm_formatted"; 2356 2357 private static final Validator NEXT_ALARM_FORMATTED_VALIDATOR = new Validator() { 2358 private static final int MAX_LENGTH = 1000; 2359 2360 @Override 2361 public boolean validate(String value) { 2362 // TODO: No idea what the correct format is. 2363 return value == null || value.length() < MAX_LENGTH; 2364 } 2365 }; 2366 2367 /** 2368 * Scaling factor for fonts, float. 2369 */ 2370 public static final String FONT_SCALE = "font_scale"; 2371 2372 private static final Validator FONT_SCALE_VALIDATOR = new Validator() { 2373 @Override 2374 public boolean validate(String value) { 2375 try { 2376 return Float.parseFloat(value) >= 0; 2377 } catch (NumberFormatException e) { 2378 return false; 2379 } 2380 } 2381 }; 2382 2383 /** 2384 * Name of an application package to be debugged. 2385 * 2386 * @deprecated Use {@link Global#DEBUG_APP} instead 2387 */ 2388 @Deprecated 2389 public static final String DEBUG_APP = Global.DEBUG_APP; 2390 2391 /** 2392 * If 1, when launching DEBUG_APP it will wait for the debugger before 2393 * starting user code. If 0, it will run normally. 2394 * 2395 * @deprecated Use {@link Global#WAIT_FOR_DEBUGGER} instead 2396 */ 2397 @Deprecated 2398 public static final String WAIT_FOR_DEBUGGER = Global.WAIT_FOR_DEBUGGER; 2399 2400 /** 2401 * Whether or not to dim the screen. 0=no 1=yes 2402 * @deprecated This setting is no longer used. 2403 */ 2404 @Deprecated 2405 public static final String DIM_SCREEN = "dim_screen"; 2406 2407 private static final Validator DIM_SCREEN_VALIDATOR = sBooleanValidator; 2408 2409 /** 2410 * The amount of time in milliseconds before the device goes to sleep or begins 2411 * to dream after a period of inactivity. This value is also known as the 2412 * user activity timeout period since the screen isn't necessarily turned off 2413 * when it expires. 2414 */ 2415 public static final String SCREEN_OFF_TIMEOUT = "screen_off_timeout"; 2416 2417 private static final Validator SCREEN_OFF_TIMEOUT_VALIDATOR = sNonNegativeIntegerValidator; 2418 2419 /** 2420 * The screen backlight brightness between 0 and 255. 2421 */ 2422 public static final String SCREEN_BRIGHTNESS = "screen_brightness"; 2423 2424 private static final Validator SCREEN_BRIGHTNESS_VALIDATOR = 2425 new InclusiveIntegerRangeValidator(0, 255); 2426 2427 /** 2428 * Control whether to enable automatic brightness mode. 2429 */ 2430 public static final String SCREEN_BRIGHTNESS_MODE = "screen_brightness_mode"; 2431 2432 private static final Validator SCREEN_BRIGHTNESS_MODE_VALIDATOR = sBooleanValidator; 2433 2434 /** 2435 * Adjustment to auto-brightness to make it generally more (>0.0 <1.0) 2436 * or less (<0.0 >-1.0) bright. 2437 * @hide 2438 */ 2439 public static final String SCREEN_AUTO_BRIGHTNESS_ADJ = "screen_auto_brightness_adj"; 2440 2441 private static final Validator SCREEN_AUTO_BRIGHTNESS_ADJ_VALIDATOR = 2442 new InclusiveFloatRangeValidator(-1, 1); 2443 2444 /** 2445 * SCREEN_BRIGHTNESS_MODE value for manual mode. 2446 */ 2447 public static final int SCREEN_BRIGHTNESS_MODE_MANUAL = 0; 2448 2449 /** 2450 * SCREEN_BRIGHTNESS_MODE value for automatic mode. 2451 */ 2452 public static final int SCREEN_BRIGHTNESS_MODE_AUTOMATIC = 1; 2453 2454 /** 2455 * Control whether the process CPU usage meter should be shown. 2456 * 2457 * @deprecated Use {@link Global#SHOW_PROCESSES} instead 2458 */ 2459 @Deprecated 2460 public static final String SHOW_PROCESSES = Global.SHOW_PROCESSES; 2461 2462 /** 2463 * If 1, the activity manager will aggressively finish activities and 2464 * processes as soon as they are no longer needed. If 0, the normal 2465 * extended lifetime is used. 2466 * 2467 * @deprecated Use {@link Global#ALWAYS_FINISH_ACTIVITIES} instead 2468 */ 2469 @Deprecated 2470 public static final String ALWAYS_FINISH_ACTIVITIES = Global.ALWAYS_FINISH_ACTIVITIES; 2471 2472 /** 2473 * Determines which streams are affected by ringer mode changes. The 2474 * stream type's bit should be set to 1 if it should be muted when going 2475 * into an inaudible ringer mode. 2476 */ 2477 public static final String MODE_RINGER_STREAMS_AFFECTED = "mode_ringer_streams_affected"; 2478 2479 private static final Validator MODE_RINGER_STREAMS_AFFECTED_VALIDATOR = 2480 sNonNegativeIntegerValidator; 2481 2482 /** 2483 * Determines which streams are affected by mute. The 2484 * stream type's bit should be set to 1 if it should be muted when a mute request 2485 * is received. 2486 */ 2487 public static final String MUTE_STREAMS_AFFECTED = "mute_streams_affected"; 2488 2489 private static final Validator MUTE_STREAMS_AFFECTED_VALIDATOR = 2490 sNonNegativeIntegerValidator; 2491 2492 /** 2493 * Whether vibrate is on for different events. This is used internally, 2494 * changing this value will not change the vibrate. See AudioManager. 2495 */ 2496 public static final String VIBRATE_ON = "vibrate_on"; 2497 2498 private static final Validator VIBRATE_ON_VALIDATOR = sBooleanValidator; 2499 2500 /** 2501 * If 1, redirects the system vibrator to all currently attached input devices 2502 * that support vibration. If there are no such input devices, then the system 2503 * vibrator is used instead. 2504 * If 0, does not register the system vibrator. 2505 * 2506 * This setting is mainly intended to provide a compatibility mechanism for 2507 * applications that only know about the system vibrator and do not use the 2508 * input device vibrator API. 2509 * 2510 * @hide 2511 */ 2512 public static final String VIBRATE_INPUT_DEVICES = "vibrate_input_devices"; 2513 2514 private static final Validator VIBRATE_INPUT_DEVICES_VALIDATOR = sBooleanValidator; 2515 2516 /** 2517 * Ringer volume. This is used internally, changing this value will not 2518 * change the volume. See AudioManager. 2519 * 2520 * @removed Not used by anything since API 2. 2521 */ 2522 public static final String VOLUME_RING = "volume_ring"; 2523 2524 /** 2525 * System/notifications volume. This is used internally, changing this 2526 * value will not change the volume. See AudioManager. 2527 * 2528 * @removed Not used by anything since API 2. 2529 */ 2530 public static final String VOLUME_SYSTEM = "volume_system"; 2531 2532 /** 2533 * Voice call volume. This is used internally, changing this value will 2534 * not change the volume. See AudioManager. 2535 * 2536 * @removed Not used by anything since API 2. 2537 */ 2538 public static final String VOLUME_VOICE = "volume_voice"; 2539 2540 /** 2541 * Music/media/gaming volume. This is used internally, changing this 2542 * value will not change the volume. See AudioManager. 2543 * 2544 * @removed Not used by anything since API 2. 2545 */ 2546 public static final String VOLUME_MUSIC = "volume_music"; 2547 2548 /** 2549 * Alarm volume. This is used internally, changing this 2550 * value will not change the volume. See AudioManager. 2551 * 2552 * @removed Not used by anything since API 2. 2553 */ 2554 public static final String VOLUME_ALARM = "volume_alarm"; 2555 2556 /** 2557 * Notification volume. This is used internally, changing this 2558 * value will not change the volume. See AudioManager. 2559 * 2560 * @removed Not used by anything since API 2. 2561 */ 2562 public static final String VOLUME_NOTIFICATION = "volume_notification"; 2563 2564 /** 2565 * Bluetooth Headset volume. This is used internally, changing this value will 2566 * not change the volume. See AudioManager. 2567 * 2568 * @removed Not used by anything since API 2. 2569 */ 2570 public static final String VOLUME_BLUETOOTH_SCO = "volume_bluetooth_sco"; 2571 2572 /** 2573 * Master volume (float in the range 0.0f to 1.0f). 2574 * 2575 * @hide 2576 */ 2577 public static final String VOLUME_MASTER = "volume_master"; 2578 2579 /** 2580 * Master volume mute (int 1 = mute, 0 = not muted). 2581 * 2582 * @hide 2583 */ 2584 public static final String VOLUME_MASTER_MUTE = "volume_master_mute"; 2585 2586 private static final Validator VOLUME_MASTER_MUTE_VALIDATOR = sBooleanValidator; 2587 2588 /** 2589 * Microphone mute (int 1 = mute, 0 = not muted). 2590 * 2591 * @hide 2592 */ 2593 public static final String MICROPHONE_MUTE = "microphone_mute"; 2594 2595 private static final Validator MICROPHONE_MUTE_VALIDATOR = sBooleanValidator; 2596 2597 /** 2598 * Whether the notifications should use the ring volume (value of 1) or 2599 * a separate notification volume (value of 0). In most cases, users 2600 * will have this enabled so the notification and ringer volumes will be 2601 * the same. However, power users can disable this and use the separate 2602 * notification volume control. 2603 * <p> 2604 * Note: This is a one-off setting that will be removed in the future 2605 * when there is profile support. For this reason, it is kept hidden 2606 * from the public APIs. 2607 * 2608 * @hide 2609 * @deprecated 2610 */ 2611 @Deprecated 2612 public static final String NOTIFICATIONS_USE_RING_VOLUME = 2613 "notifications_use_ring_volume"; 2614 2615 private static final Validator NOTIFICATIONS_USE_RING_VOLUME_VALIDATOR = sBooleanValidator; 2616 2617 /** 2618 * Whether silent mode should allow vibration feedback. This is used 2619 * internally in AudioService and the Sound settings activity to 2620 * coordinate decoupling of vibrate and silent modes. This setting 2621 * will likely be removed in a future release with support for 2622 * audio/vibe feedback profiles. 2623 * 2624 * Not used anymore. On devices with vibrator, the user explicitly selects 2625 * silent or vibrate mode. 2626 * Kept for use by legacy database upgrade code in DatabaseHelper. 2627 * @hide 2628 */ 2629 public static final String VIBRATE_IN_SILENT = "vibrate_in_silent"; 2630 2631 private static final Validator VIBRATE_IN_SILENT_VALIDATOR = sBooleanValidator; 2632 2633 /** 2634 * The mapping of stream type (integer) to its setting. 2635 * 2636 * @removed Not used by anything since API 2. 2637 */ 2638 public static final String[] VOLUME_SETTINGS = { 2639 VOLUME_VOICE, VOLUME_SYSTEM, VOLUME_RING, VOLUME_MUSIC, 2640 VOLUME_ALARM, VOLUME_NOTIFICATION, VOLUME_BLUETOOTH_SCO 2641 }; 2642 2643 /** 2644 * Appended to various volume related settings to record the previous 2645 * values before they the settings were affected by a silent/vibrate 2646 * ringer mode change. 2647 * 2648 * @removed Not used by anything since API 2. 2649 */ 2650 public static final String APPEND_FOR_LAST_AUDIBLE = "_last_audible"; 2651 2652 /** 2653 * Persistent store for the system-wide default ringtone URI. 2654 * <p> 2655 * If you need to play the default ringtone at any given time, it is recommended 2656 * you give {@link #DEFAULT_RINGTONE_URI} to the media player. It will resolve 2657 * to the set default ringtone at the time of playing. 2658 * 2659 * @see #DEFAULT_RINGTONE_URI 2660 */ 2661 public static final String RINGTONE = "ringtone"; 2662 2663 private static final Validator RINGTONE_VALIDATOR = sUriValidator; 2664 2665 /** 2666 * A {@link Uri} that will point to the current default ringtone at any 2667 * given time. 2668 * <p> 2669 * If the current default ringtone is in the DRM provider and the caller 2670 * does not have permission, the exception will be a 2671 * FileNotFoundException. 2672 */ 2673 public static final Uri DEFAULT_RINGTONE_URI = getUriFor(RINGTONE); 2674 2675 /** 2676 * Persistent store for the system-wide default notification sound. 2677 * 2678 * @see #RINGTONE 2679 * @see #DEFAULT_NOTIFICATION_URI 2680 */ 2681 public static final String NOTIFICATION_SOUND = "notification_sound"; 2682 2683 private static final Validator NOTIFICATION_SOUND_VALIDATOR = sUriValidator; 2684 2685 /** 2686 * A {@link Uri} that will point to the current default notification 2687 * sound at any given time. 2688 * 2689 * @see #DEFAULT_RINGTONE_URI 2690 */ 2691 public static final Uri DEFAULT_NOTIFICATION_URI = getUriFor(NOTIFICATION_SOUND); 2692 2693 /** 2694 * Persistent store for the system-wide default alarm alert. 2695 * 2696 * @see #RINGTONE 2697 * @see #DEFAULT_ALARM_ALERT_URI 2698 */ 2699 public static final String ALARM_ALERT = "alarm_alert"; 2700 2701 private static final Validator ALARM_ALERT_VALIDATOR = sUriValidator; 2702 2703 /** 2704 * A {@link Uri} that will point to the current default alarm alert at 2705 * any given time. 2706 * 2707 * @see #DEFAULT_ALARM_ALERT_URI 2708 */ 2709 public static final Uri DEFAULT_ALARM_ALERT_URI = getUriFor(ALARM_ALERT); 2710 2711 /** 2712 * Persistent store for the system default media button event receiver. 2713 * 2714 * @hide 2715 */ 2716 public static final String MEDIA_BUTTON_RECEIVER = "media_button_receiver"; 2717 2718 private static final Validator MEDIA_BUTTON_RECEIVER_VALIDATOR = new Validator() { 2719 @Override 2720 public boolean validate(String value) { 2721 try { 2722 ComponentName.unflattenFromString(value); 2723 return true; 2724 } catch (NullPointerException e) { 2725 return false; 2726 } 2727 } 2728 }; 2729 2730 /** 2731 * Setting to enable Auto Replace (AutoText) in text editors. 1 = On, 0 = Off 2732 */ 2733 public static final String TEXT_AUTO_REPLACE = "auto_replace"; 2734 2735 private static final Validator TEXT_AUTO_REPLACE_VALIDATOR = sBooleanValidator; 2736 2737 /** 2738 * Setting to enable Auto Caps in text editors. 1 = On, 0 = Off 2739 */ 2740 public static final String TEXT_AUTO_CAPS = "auto_caps"; 2741 2742 private static final Validator TEXT_AUTO_CAPS_VALIDATOR = sBooleanValidator; 2743 2744 /** 2745 * Setting to enable Auto Punctuate in text editors. 1 = On, 0 = Off. This 2746 * feature converts two spaces to a "." and space. 2747 */ 2748 public static final String TEXT_AUTO_PUNCTUATE = "auto_punctuate"; 2749 2750 private static final Validator TEXT_AUTO_PUNCTUATE_VALIDATOR = sBooleanValidator; 2751 2752 /** 2753 * Setting to showing password characters in text editors. 1 = On, 0 = Off 2754 */ 2755 public static final String TEXT_SHOW_PASSWORD = "show_password"; 2756 2757 private static final Validator TEXT_SHOW_PASSWORD_VALIDATOR = sBooleanValidator; 2758 2759 public static final String SHOW_GTALK_SERVICE_STATUS = 2760 "SHOW_GTALK_SERVICE_STATUS"; 2761 2762 private static final Validator SHOW_GTALK_SERVICE_STATUS_VALIDATOR = sBooleanValidator; 2763 2764 /** 2765 * Name of activity to use for wallpaper on the home screen. 2766 * 2767 * @deprecated Use {@link WallpaperManager} instead. 2768 */ 2769 @Deprecated 2770 public static final String WALLPAPER_ACTIVITY = "wallpaper_activity"; 2771 2772 private static final Validator WALLPAPER_ACTIVITY_VALIDATOR = new Validator() { 2773 private static final int MAX_LENGTH = 1000; 2774 2775 @Override 2776 public boolean validate(String value) { 2777 if (value != null && value.length() > MAX_LENGTH) { 2778 return false; 2779 } 2780 return ComponentName.unflattenFromString(value) != null; 2781 } 2782 }; 2783 2784 /** 2785 * @deprecated Use {@link android.provider.Settings.Global#AUTO_TIME} 2786 * instead 2787 */ 2788 @Deprecated 2789 public static final String AUTO_TIME = Global.AUTO_TIME; 2790 2791 /** 2792 * @deprecated Use {@link android.provider.Settings.Global#AUTO_TIME_ZONE} 2793 * instead 2794 */ 2795 @Deprecated 2796 public static final String AUTO_TIME_ZONE = Global.AUTO_TIME_ZONE; 2797 2798 /** 2799 * Display times as 12 or 24 hours 2800 * 12 2801 * 24 2802 */ 2803 public static final String TIME_12_24 = "time_12_24"; 2804 2805 /** @hide */ 2806 public static final Validator TIME_12_24_VALIDATOR = 2807 new DiscreteValueValidator(new String[] {"12", "24"}); 2808 2809 /** 2810 * Date format string 2811 * mm/dd/yyyy 2812 * dd/mm/yyyy 2813 * yyyy/mm/dd 2814 */ 2815 public static final String DATE_FORMAT = "date_format"; 2816 2817 /** @hide */ 2818 public static final Validator DATE_FORMAT_VALIDATOR = new Validator() { 2819 @Override 2820 public boolean validate(String value) { 2821 try { 2822 new SimpleDateFormat(value); 2823 return true; 2824 } catch (IllegalArgumentException e) { 2825 return false; 2826 } 2827 } 2828 }; 2829 2830 /** 2831 * Whether the setup wizard has been run before (on first boot), or if 2832 * it still needs to be run. 2833 * 2834 * nonzero = it has been run in the past 2835 * 0 = it has not been run in the past 2836 */ 2837 public static final String SETUP_WIZARD_HAS_RUN = "setup_wizard_has_run"; 2838 2839 /** @hide */ 2840 public static final Validator SETUP_WIZARD_HAS_RUN_VALIDATOR = sBooleanValidator; 2841 2842 /** 2843 * Scaling factor for normal window animations. Setting to 0 will disable window 2844 * animations. 2845 * 2846 * @deprecated Use {@link Global#WINDOW_ANIMATION_SCALE} instead 2847 */ 2848 @Deprecated 2849 public static final String WINDOW_ANIMATION_SCALE = Global.WINDOW_ANIMATION_SCALE; 2850 2851 /** 2852 * Scaling factor for activity transition animations. Setting to 0 will disable window 2853 * animations. 2854 * 2855 * @deprecated Use {@link Global#TRANSITION_ANIMATION_SCALE} instead 2856 */ 2857 @Deprecated 2858 public static final String TRANSITION_ANIMATION_SCALE = Global.TRANSITION_ANIMATION_SCALE; 2859 2860 /** 2861 * Scaling factor for Animator-based animations. This affects both the start delay and 2862 * duration of all such animations. Setting to 0 will cause animations to end immediately. 2863 * The default value is 1. 2864 * 2865 * @deprecated Use {@link Global#ANIMATOR_DURATION_SCALE} instead 2866 */ 2867 @Deprecated 2868 public static final String ANIMATOR_DURATION_SCALE = Global.ANIMATOR_DURATION_SCALE; 2869 2870 /** 2871 * Control whether the accelerometer will be used to change screen 2872 * orientation. If 0, it will not be used unless explicitly requested 2873 * by the application; if 1, it will be used by default unless explicitly 2874 * disabled by the application. 2875 */ 2876 public static final String ACCELEROMETER_ROTATION = "accelerometer_rotation"; 2877 2878 /** @hide */ 2879 public static final Validator ACCELEROMETER_ROTATION_VALIDATOR = sBooleanValidator; 2880 2881 /** 2882 * Default screen rotation when no other policy applies. 2883 * When {@link #ACCELEROMETER_ROTATION} is zero and no on-screen Activity expresses a 2884 * preference, this rotation value will be used. Must be one of the 2885 * {@link android.view.Surface#ROTATION_0 Surface rotation constants}. 2886 * 2887 * @see android.view.Display#getRotation 2888 */ 2889 public static final String USER_ROTATION = "user_rotation"; 2890 2891 /** @hide */ 2892 public static final Validator USER_ROTATION_VALIDATOR = 2893 new InclusiveIntegerRangeValidator(0, 3); 2894 2895 /** 2896 * Control whether the rotation lock toggle in the System UI should be hidden. 2897 * Typically this is done for accessibility purposes to make it harder for 2898 * the user to accidentally toggle the rotation lock while the display rotation 2899 * has been locked for accessibility. 2900 * 2901 * If 0, then rotation lock toggle is not hidden for accessibility (although it may be 2902 * unavailable for other reasons). If 1, then the rotation lock toggle is hidden. 2903 * 2904 * @hide 2905 */ 2906 public static final String HIDE_ROTATION_LOCK_TOGGLE_FOR_ACCESSIBILITY = 2907 "hide_rotation_lock_toggle_for_accessibility"; 2908 2909 /** @hide */ 2910 public static final Validator HIDE_ROTATION_LOCK_TOGGLE_FOR_ACCESSIBILITY_VALIDATOR = 2911 sBooleanValidator; 2912 2913 /** 2914 * Whether the phone vibrates when it is ringing due to an incoming call. This will 2915 * be used by Phone and Setting apps; it shouldn't affect other apps. 2916 * The value is boolean (1 or 0). 2917 * 2918 * Note: this is not same as "vibrate on ring", which had been available until ICS. 2919 * It was about AudioManager's setting and thus affected all the applications which 2920 * relied on the setting, while this is purely about the vibration setting for incoming 2921 * calls. 2922 */ 2923 public static final String VIBRATE_WHEN_RINGING = "vibrate_when_ringing"; 2924 2925 /** @hide */ 2926 public static final Validator VIBRATE_WHEN_RINGING_VALIDATOR = sBooleanValidator; 2927 2928 /** 2929 * Whether the audible DTMF tones are played by the dialer when dialing. The value is 2930 * boolean (1 or 0). 2931 */ 2932 public static final String DTMF_TONE_WHEN_DIALING = "dtmf_tone"; 2933 2934 /** @hide */ 2935 public static final Validator DTMF_TONE_WHEN_DIALING_VALIDATOR = sBooleanValidator; 2936 2937 /** 2938 * CDMA only settings 2939 * DTMF tone type played by the dialer when dialing. 2940 * 0 = Normal 2941 * 1 = Long 2942 */ 2943 public static final String DTMF_TONE_TYPE_WHEN_DIALING = "dtmf_tone_type"; 2944 2945 /** @hide */ 2946 public static final Validator DTMF_TONE_TYPE_WHEN_DIALING_VALIDATOR = sBooleanValidator; 2947 2948 /** 2949 * Whether the hearing aid is enabled. The value is 2950 * boolean (1 or 0). 2951 * @hide 2952 */ 2953 public static final String HEARING_AID = "hearing_aid"; 2954 2955 /** @hide */ 2956 public static final Validator HEARING_AID_VALIDATOR = sBooleanValidator; 2957 2958 /** 2959 * CDMA only settings 2960 * TTY Mode 2961 * 0 = OFF 2962 * 1 = FULL 2963 * 2 = VCO 2964 * 3 = HCO 2965 * @hide 2966 */ 2967 public static final String TTY_MODE = "tty_mode"; 2968 2969 /** @hide */ 2970 public static final Validator TTY_MODE_VALIDATOR = new InclusiveIntegerRangeValidator(0, 3); 2971 2972 /** 2973 * Whether the sounds effects (key clicks, lid open ...) are enabled. The value is 2974 * boolean (1 or 0). 2975 */ 2976 public static final String SOUND_EFFECTS_ENABLED = "sound_effects_enabled"; 2977 2978 /** @hide */ 2979 public static final Validator SOUND_EFFECTS_ENABLED_VALIDATOR = sBooleanValidator; 2980 2981 /** 2982 * Whether the haptic feedback (long presses, ...) are enabled. The value is 2983 * boolean (1 or 0). 2984 */ 2985 public static final String HAPTIC_FEEDBACK_ENABLED = "haptic_feedback_enabled"; 2986 2987 /** @hide */ 2988 public static final Validator HAPTIC_FEEDBACK_ENABLED_VALIDATOR = sBooleanValidator; 2989 2990 /** 2991 * @deprecated Each application that shows web suggestions should have its own 2992 * setting for this. 2993 */ 2994 @Deprecated 2995 public static final String SHOW_WEB_SUGGESTIONS = "show_web_suggestions"; 2996 2997 /** @hide */ 2998 public static final Validator SHOW_WEB_SUGGESTIONS_VALIDATOR = sBooleanValidator; 2999 3000 /** 3001 * Whether the notification LED should repeatedly flash when a notification is 3002 * pending. The value is boolean (1 or 0). 3003 * @hide 3004 */ 3005 public static final String NOTIFICATION_LIGHT_PULSE = "notification_light_pulse"; 3006 3007 /** @hide */ 3008 public static final Validator NOTIFICATION_LIGHT_PULSE_VALIDATOR = sBooleanValidator; 3009 3010 /** 3011 * Show pointer location on screen? 3012 * 0 = no 3013 * 1 = yes 3014 * @hide 3015 */ 3016 public static final String POINTER_LOCATION = "pointer_location"; 3017 3018 /** @hide */ 3019 public static final Validator POINTER_LOCATION_VALIDATOR = sBooleanValidator; 3020 3021 /** 3022 * Show touch positions on screen? 3023 * 0 = no 3024 * 1 = yes 3025 * @hide 3026 */ 3027 public static final String SHOW_TOUCHES = "show_touches"; 3028 3029 /** @hide */ 3030 public static final Validator SHOW_TOUCHES_VALIDATOR = sBooleanValidator; 3031 3032 /** 3033 * Log raw orientation data from 3034 * {@link com.android.server.policy.WindowOrientationListener} for use with the 3035 * orientationplot.py tool. 3036 * 0 = no 3037 * 1 = yes 3038 * @hide 3039 */ 3040 public static final String WINDOW_ORIENTATION_LISTENER_LOG = 3041 "window_orientation_listener_log"; 3042 3043 /** @hide */ 3044 public static final Validator WINDOW_ORIENTATION_LISTENER_LOG_VALIDATOR = sBooleanValidator; 3045 3046 /** 3047 * @deprecated Use {@link android.provider.Settings.Global#POWER_SOUNDS_ENABLED} 3048 * instead 3049 * @hide 3050 */ 3051 @Deprecated 3052 public static final String POWER_SOUNDS_ENABLED = Global.POWER_SOUNDS_ENABLED; 3053 3054 /** 3055 * @deprecated Use {@link android.provider.Settings.Global#DOCK_SOUNDS_ENABLED} 3056 * instead 3057 * @hide 3058 */ 3059 @Deprecated 3060 public static final String DOCK_SOUNDS_ENABLED = Global.DOCK_SOUNDS_ENABLED; 3061 3062 /** 3063 * Whether to play sounds when the keyguard is shown and dismissed. 3064 * @hide 3065 */ 3066 public static final String LOCKSCREEN_SOUNDS_ENABLED = "lockscreen_sounds_enabled"; 3067 3068 /** @hide */ 3069 public static final Validator LOCKSCREEN_SOUNDS_ENABLED_VALIDATOR = sBooleanValidator; 3070 3071 /** 3072 * Whether the lockscreen should be completely disabled. 3073 * @hide 3074 */ 3075 public static final String LOCKSCREEN_DISABLED = "lockscreen.disabled"; 3076 3077 /** @hide */ 3078 public static final Validator LOCKSCREEN_DISABLED_VALIDATOR = sBooleanValidator; 3079 3080 /** 3081 * @deprecated Use {@link android.provider.Settings.Global#LOW_BATTERY_SOUND} 3082 * instead 3083 * @hide 3084 */ 3085 @Deprecated 3086 public static final String LOW_BATTERY_SOUND = Global.LOW_BATTERY_SOUND; 3087 3088 /** 3089 * @deprecated Use {@link android.provider.Settings.Global#DESK_DOCK_SOUND} 3090 * instead 3091 * @hide 3092 */ 3093 @Deprecated 3094 public static final String DESK_DOCK_SOUND = Global.DESK_DOCK_SOUND; 3095 3096 /** 3097 * @deprecated Use {@link android.provider.Settings.Global#DESK_UNDOCK_SOUND} 3098 * instead 3099 * @hide 3100 */ 3101 @Deprecated 3102 public static final String DESK_UNDOCK_SOUND = Global.DESK_UNDOCK_SOUND; 3103 3104 /** 3105 * @deprecated Use {@link android.provider.Settings.Global#CAR_DOCK_SOUND} 3106 * instead 3107 * @hide 3108 */ 3109 @Deprecated 3110 public static final String CAR_DOCK_SOUND = Global.CAR_DOCK_SOUND; 3111 3112 /** 3113 * @deprecated Use {@link android.provider.Settings.Global#CAR_UNDOCK_SOUND} 3114 * instead 3115 * @hide 3116 */ 3117 @Deprecated 3118 public static final String CAR_UNDOCK_SOUND = Global.CAR_UNDOCK_SOUND; 3119 3120 /** 3121 * @deprecated Use {@link android.provider.Settings.Global#LOCK_SOUND} 3122 * instead 3123 * @hide 3124 */ 3125 @Deprecated 3126 public static final String LOCK_SOUND = Global.LOCK_SOUND; 3127 3128 /** 3129 * @deprecated Use {@link android.provider.Settings.Global#UNLOCK_SOUND} 3130 * instead 3131 * @hide 3132 */ 3133 @Deprecated 3134 public static final String UNLOCK_SOUND = Global.UNLOCK_SOUND; 3135 3136 /** 3137 * Receive incoming SIP calls? 3138 * 0 = no 3139 * 1 = yes 3140 * @hide 3141 */ 3142 public static final String SIP_RECEIVE_CALLS = "sip_receive_calls"; 3143 3144 /** @hide */ 3145 public static final Validator SIP_RECEIVE_CALLS_VALIDATOR = sBooleanValidator; 3146 3147 /** 3148 * Call Preference String. 3149 * "SIP_ALWAYS" : Always use SIP with network access 3150 * "SIP_ADDRESS_ONLY" : Only if destination is a SIP address 3151 * @hide 3152 */ 3153 public static final String SIP_CALL_OPTIONS = "sip_call_options"; 3154 3155 /** @hide */ 3156 public static final Validator SIP_CALL_OPTIONS_VALIDATOR = new DiscreteValueValidator( 3157 new String[] {"SIP_ALWAYS", "SIP_ADDRESS_ONLY"}); 3158 3159 /** 3160 * One of the sip call options: Always use SIP with network access. 3161 * @hide 3162 */ 3163 public static final String SIP_ALWAYS = "SIP_ALWAYS"; 3164 3165 /** @hide */ 3166 public static final Validator SIP_ALWAYS_VALIDATOR = sBooleanValidator; 3167 3168 /** 3169 * One of the sip call options: Only if destination is a SIP address. 3170 * @hide 3171 */ 3172 public static final String SIP_ADDRESS_ONLY = "SIP_ADDRESS_ONLY"; 3173 3174 /** @hide */ 3175 public static final Validator SIP_ADDRESS_ONLY_VALIDATOR = sBooleanValidator; 3176 3177 /** 3178 * @deprecated Use SIP_ALWAYS or SIP_ADDRESS_ONLY instead. Formerly used to indicate that 3179 * the user should be prompted each time a call is made whether it should be placed using 3180 * SIP. The {@link com.android.providers.settings.DatabaseHelper} replaces this with 3181 * SIP_ADDRESS_ONLY. 3182 * @hide 3183 */ 3184 @Deprecated 3185 public static final String SIP_ASK_ME_EACH_TIME = "SIP_ASK_ME_EACH_TIME"; 3186 3187 /** @hide */ 3188 public static final Validator SIP_ASK_ME_EACH_TIME_VALIDATOR = sBooleanValidator; 3189 3190 /** 3191 * Pointer speed setting. 3192 * This is an integer value in a range between -7 and +7, so there are 15 possible values. 3193 * -7 = slowest 3194 * 0 = default speed 3195 * +7 = fastest 3196 * @hide 3197 */ 3198 public static final String POINTER_SPEED = "pointer_speed"; 3199 3200 /** @hide */ 3201 public static final Validator POINTER_SPEED_VALIDATOR = 3202 new InclusiveFloatRangeValidator(-7, 7); 3203 3204 /** 3205 * Whether lock-to-app will be triggered by long-press on recents. 3206 * @hide 3207 */ 3208 public static final String LOCK_TO_APP_ENABLED = "lock_to_app_enabled"; 3209 3210 /** @hide */ 3211 public static final Validator LOCK_TO_APP_ENABLED_VALIDATOR = sBooleanValidator; 3212 3213 /** 3214 * I am the lolrus. 3215 * <p> 3216 * Nonzero values indicate that the user has a bukkit. 3217 * Backward-compatible with <code>PrefGetPreference(prefAllowEasterEggs)</code>. 3218 * @hide 3219 */ 3220 public static final String EGG_MODE = "egg_mode"; 3221 3222 /** @hide */ 3223 public static final Validator EGG_MODE_VALIDATOR = new Validator() { 3224 @Override 3225 public boolean validate(String value) { 3226 try { 3227 return Long.parseLong(value) >= 0; 3228 } catch (NumberFormatException e) { 3229 return false; 3230 } 3231 } 3232 }; 3233 3234 /** 3235 * IMPORTANT: If you add a new public settings you also have to add it to 3236 * PUBLIC_SETTINGS below. If the new setting is hidden you have to add 3237 * it to PRIVATE_SETTINGS below. Also add a validator that can validate 3238 * the setting value. See an example above. 3239 */ 3240 3241 /** 3242 * Settings to backup. This is here so that it's in the same place as the settings 3243 * keys and easy to update. 3244 * 3245 * NOTE: Settings are backed up and restored in the order they appear 3246 * in this array. If you have one setting depending on another, 3247 * make sure that they are ordered appropriately. 3248 * 3249 * @hide 3250 */ 3251 public static final String[] SETTINGS_TO_BACKUP = { 3252 STAY_ON_WHILE_PLUGGED_IN, // moved to global 3253 WIFI_USE_STATIC_IP, 3254 WIFI_STATIC_IP, 3255 WIFI_STATIC_GATEWAY, 3256 WIFI_STATIC_NETMASK, 3257 WIFI_STATIC_DNS1, 3258 WIFI_STATIC_DNS2, 3259 BLUETOOTH_DISCOVERABILITY, 3260 BLUETOOTH_DISCOVERABILITY_TIMEOUT, 3261 DIM_SCREEN, 3262 SCREEN_OFF_TIMEOUT, 3263 SCREEN_BRIGHTNESS, 3264 SCREEN_BRIGHTNESS_MODE, 3265 SCREEN_AUTO_BRIGHTNESS_ADJ, 3266 VIBRATE_INPUT_DEVICES, 3267 MODE_RINGER_STREAMS_AFFECTED, 3268 TEXT_AUTO_REPLACE, 3269 TEXT_AUTO_CAPS, 3270 TEXT_AUTO_PUNCTUATE, 3271 TEXT_SHOW_PASSWORD, 3272 AUTO_TIME, // moved to global 3273 AUTO_TIME_ZONE, // moved to global 3274 TIME_12_24, 3275 DATE_FORMAT, 3276 DTMF_TONE_WHEN_DIALING, 3277 DTMF_TONE_TYPE_WHEN_DIALING, 3278 HEARING_AID, 3279 TTY_MODE, 3280 SOUND_EFFECTS_ENABLED, 3281 HAPTIC_FEEDBACK_ENABLED, 3282 POWER_SOUNDS_ENABLED, // moved to global 3283 DOCK_SOUNDS_ENABLED, // moved to global 3284 LOCKSCREEN_SOUNDS_ENABLED, 3285 SHOW_WEB_SUGGESTIONS, 3286 NOTIFICATION_LIGHT_PULSE, 3287 SIP_CALL_OPTIONS, 3288 SIP_RECEIVE_CALLS, 3289 POINTER_SPEED, 3290 VIBRATE_WHEN_RINGING, 3291 RINGTONE, 3292 LOCK_TO_APP_ENABLED, 3293 NOTIFICATION_SOUND 3294 }; 3295 3296 /** 3297 * These are all public system settings 3298 * 3299 * @hide 3300 */ 3301 public static final Set<String> PUBLIC_SETTINGS = new ArraySet<>(); 3302 static { 3303 PUBLIC_SETTINGS.add(END_BUTTON_BEHAVIOR); 3304 PUBLIC_SETTINGS.add(WIFI_USE_STATIC_IP); 3305 PUBLIC_SETTINGS.add(WIFI_STATIC_IP); 3306 PUBLIC_SETTINGS.add(WIFI_STATIC_GATEWAY); 3307 PUBLIC_SETTINGS.add(WIFI_STATIC_NETMASK); 3308 PUBLIC_SETTINGS.add(WIFI_STATIC_DNS1); 3309 PUBLIC_SETTINGS.add(WIFI_STATIC_DNS2); 3310 PUBLIC_SETTINGS.add(BLUETOOTH_DISCOVERABILITY); 3311 PUBLIC_SETTINGS.add(BLUETOOTH_DISCOVERABILITY_TIMEOUT); 3312 PUBLIC_SETTINGS.add(NEXT_ALARM_FORMATTED); 3313 PUBLIC_SETTINGS.add(FONT_SCALE); 3314 PUBLIC_SETTINGS.add(DIM_SCREEN); 3315 PUBLIC_SETTINGS.add(SCREEN_OFF_TIMEOUT); 3316 PUBLIC_SETTINGS.add(SCREEN_BRIGHTNESS); 3317 PUBLIC_SETTINGS.add(SCREEN_BRIGHTNESS_MODE); 3318 PUBLIC_SETTINGS.add(MODE_RINGER_STREAMS_AFFECTED); 3319 PUBLIC_SETTINGS.add(MUTE_STREAMS_AFFECTED); 3320 PUBLIC_SETTINGS.add(VIBRATE_ON); 3321 PUBLIC_SETTINGS.add(VOLUME_RING); 3322 PUBLIC_SETTINGS.add(VOLUME_SYSTEM); 3323 PUBLIC_SETTINGS.add(VOLUME_VOICE); 3324 PUBLIC_SETTINGS.add(VOLUME_MUSIC); 3325 PUBLIC_SETTINGS.add(VOLUME_ALARM); 3326 PUBLIC_SETTINGS.add(VOLUME_NOTIFICATION); 3327 PUBLIC_SETTINGS.add(VOLUME_BLUETOOTH_SCO); 3328 PUBLIC_SETTINGS.add(RINGTONE); 3329 PUBLIC_SETTINGS.add(NOTIFICATION_SOUND); 3330 PUBLIC_SETTINGS.add(ALARM_ALERT); 3331 PUBLIC_SETTINGS.add(TEXT_AUTO_REPLACE); 3332 PUBLIC_SETTINGS.add(TEXT_AUTO_CAPS); 3333 PUBLIC_SETTINGS.add(TEXT_AUTO_PUNCTUATE); 3334 PUBLIC_SETTINGS.add(TEXT_SHOW_PASSWORD); 3335 PUBLIC_SETTINGS.add(SHOW_GTALK_SERVICE_STATUS); 3336 PUBLIC_SETTINGS.add(WALLPAPER_ACTIVITY); 3337 PUBLIC_SETTINGS.add(TIME_12_24); 3338 PUBLIC_SETTINGS.add(DATE_FORMAT); 3339 PUBLIC_SETTINGS.add(SETUP_WIZARD_HAS_RUN); 3340 PUBLIC_SETTINGS.add(ACCELEROMETER_ROTATION); 3341 PUBLIC_SETTINGS.add(USER_ROTATION); 3342 PUBLIC_SETTINGS.add(DTMF_TONE_WHEN_DIALING); 3343 PUBLIC_SETTINGS.add(SOUND_EFFECTS_ENABLED); 3344 PUBLIC_SETTINGS.add(HAPTIC_FEEDBACK_ENABLED); 3345 PUBLIC_SETTINGS.add(SHOW_WEB_SUGGESTIONS); 3346 } 3347 3348 /** 3349 * These are all hidden system settings. 3350 * 3351 * @hide 3352 */ 3353 public static final Set<String> PRIVATE_SETTINGS = new ArraySet<>(); 3354 static { 3355 PRIVATE_SETTINGS.add(WIFI_USE_STATIC_IP); 3356 PRIVATE_SETTINGS.add(END_BUTTON_BEHAVIOR); 3357 PRIVATE_SETTINGS.add(ADVANCED_SETTINGS); 3358 PRIVATE_SETTINGS.add(SCREEN_AUTO_BRIGHTNESS_ADJ); 3359 PRIVATE_SETTINGS.add(VIBRATE_INPUT_DEVICES); 3360 PRIVATE_SETTINGS.add(VOLUME_MASTER); 3361 PRIVATE_SETTINGS.add(VOLUME_MASTER_MUTE); 3362 PRIVATE_SETTINGS.add(MICROPHONE_MUTE); 3363 PRIVATE_SETTINGS.add(NOTIFICATIONS_USE_RING_VOLUME); 3364 PRIVATE_SETTINGS.add(VIBRATE_IN_SILENT); 3365 PRIVATE_SETTINGS.add(MEDIA_BUTTON_RECEIVER); 3366 PRIVATE_SETTINGS.add(HIDE_ROTATION_LOCK_TOGGLE_FOR_ACCESSIBILITY); 3367 PRIVATE_SETTINGS.add(VIBRATE_WHEN_RINGING); 3368 PRIVATE_SETTINGS.add(DTMF_TONE_TYPE_WHEN_DIALING); 3369 PRIVATE_SETTINGS.add(HEARING_AID); 3370 PRIVATE_SETTINGS.add(TTY_MODE); 3371 PRIVATE_SETTINGS.add(NOTIFICATION_LIGHT_PULSE); 3372 PRIVATE_SETTINGS.add(POINTER_LOCATION); 3373 PRIVATE_SETTINGS.add(SHOW_TOUCHES); 3374 PRIVATE_SETTINGS.add(WINDOW_ORIENTATION_LISTENER_LOG); 3375 PRIVATE_SETTINGS.add(POWER_SOUNDS_ENABLED); 3376 PRIVATE_SETTINGS.add(DOCK_SOUNDS_ENABLED); 3377 PRIVATE_SETTINGS.add(LOCKSCREEN_SOUNDS_ENABLED); 3378 PRIVATE_SETTINGS.add(LOCKSCREEN_DISABLED); 3379 PRIVATE_SETTINGS.add(LOW_BATTERY_SOUND); 3380 PRIVATE_SETTINGS.add(DESK_DOCK_SOUND); 3381 PRIVATE_SETTINGS.add(DESK_UNDOCK_SOUND); 3382 PRIVATE_SETTINGS.add(CAR_DOCK_SOUND); 3383 PRIVATE_SETTINGS.add(CAR_UNDOCK_SOUND); 3384 PRIVATE_SETTINGS.add(LOCK_SOUND); 3385 PRIVATE_SETTINGS.add(UNLOCK_SOUND); 3386 PRIVATE_SETTINGS.add(SIP_RECEIVE_CALLS); 3387 PRIVATE_SETTINGS.add(SIP_CALL_OPTIONS); 3388 PRIVATE_SETTINGS.add(SIP_ALWAYS); 3389 PRIVATE_SETTINGS.add(SIP_ADDRESS_ONLY); 3390 PRIVATE_SETTINGS.add(SIP_ASK_ME_EACH_TIME); 3391 PRIVATE_SETTINGS.add(POINTER_SPEED); 3392 PRIVATE_SETTINGS.add(LOCK_TO_APP_ENABLED); 3393 PRIVATE_SETTINGS.add(EGG_MODE); 3394 } 3395 3396 /** 3397 * These are all public system settings 3398 * 3399 * @hide 3400 */ 3401 public static final Map<String, Validator> VALIDATORS = new ArrayMap<>(); 3402 static { VALIDATORS.put(END_BUTTON_BEHAVIOR,END_BUTTON_BEHAVIOR_VALIDATOR)3403 VALIDATORS.put(END_BUTTON_BEHAVIOR,END_BUTTON_BEHAVIOR_VALIDATOR); VALIDATORS.put(WIFI_USE_STATIC_IP, WIFI_USE_STATIC_IP_VALIDATOR)3404 VALIDATORS.put(WIFI_USE_STATIC_IP, WIFI_USE_STATIC_IP_VALIDATOR); VALIDATORS.put(BLUETOOTH_DISCOVERABILITY, BLUETOOTH_DISCOVERABILITY_VALIDATOR)3405 VALIDATORS.put(BLUETOOTH_DISCOVERABILITY, BLUETOOTH_DISCOVERABILITY_VALIDATOR); VALIDATORS.put(BLUETOOTH_DISCOVERABILITY_TIMEOUT, BLUETOOTH_DISCOVERABILITY_TIMEOUT_VALIDATOR)3406 VALIDATORS.put(BLUETOOTH_DISCOVERABILITY_TIMEOUT, 3407 BLUETOOTH_DISCOVERABILITY_TIMEOUT_VALIDATOR); VALIDATORS.put(NEXT_ALARM_FORMATTED, NEXT_ALARM_FORMATTED_VALIDATOR)3408 VALIDATORS.put(NEXT_ALARM_FORMATTED, NEXT_ALARM_FORMATTED_VALIDATOR); VALIDATORS.put(FONT_SCALE, FONT_SCALE_VALIDATOR)3409 VALIDATORS.put(FONT_SCALE, FONT_SCALE_VALIDATOR); VALIDATORS.put(DIM_SCREEN, DIM_SCREEN_VALIDATOR)3410 VALIDATORS.put(DIM_SCREEN, DIM_SCREEN_VALIDATOR); VALIDATORS.put(SCREEN_OFF_TIMEOUT, SCREEN_OFF_TIMEOUT_VALIDATOR)3411 VALIDATORS.put(SCREEN_OFF_TIMEOUT, SCREEN_OFF_TIMEOUT_VALIDATOR); VALIDATORS.put(SCREEN_BRIGHTNESS, SCREEN_BRIGHTNESS_VALIDATOR)3412 VALIDATORS.put(SCREEN_BRIGHTNESS, SCREEN_BRIGHTNESS_VALIDATOR); VALIDATORS.put(SCREEN_BRIGHTNESS_MODE, SCREEN_BRIGHTNESS_MODE_VALIDATOR)3413 VALIDATORS.put(SCREEN_BRIGHTNESS_MODE, SCREEN_BRIGHTNESS_MODE_VALIDATOR); VALIDATORS.put(MODE_RINGER_STREAMS_AFFECTED, MODE_RINGER_STREAMS_AFFECTED_VALIDATOR)3414 VALIDATORS.put(MODE_RINGER_STREAMS_AFFECTED, MODE_RINGER_STREAMS_AFFECTED_VALIDATOR); VALIDATORS.put(MUTE_STREAMS_AFFECTED, MUTE_STREAMS_AFFECTED_VALIDATOR)3415 VALIDATORS.put(MUTE_STREAMS_AFFECTED, MUTE_STREAMS_AFFECTED_VALIDATOR); VALIDATORS.put(VIBRATE_ON, VIBRATE_ON_VALIDATOR)3416 VALIDATORS.put(VIBRATE_ON, VIBRATE_ON_VALIDATOR); VALIDATORS.put(RINGTONE, RINGTONE_VALIDATOR)3417 VALIDATORS.put(RINGTONE, RINGTONE_VALIDATOR); VALIDATORS.put(NOTIFICATION_SOUND, NOTIFICATION_SOUND_VALIDATOR)3418 VALIDATORS.put(NOTIFICATION_SOUND, NOTIFICATION_SOUND_VALIDATOR); VALIDATORS.put(ALARM_ALERT, ALARM_ALERT_VALIDATOR)3419 VALIDATORS.put(ALARM_ALERT, ALARM_ALERT_VALIDATOR); VALIDATORS.put(TEXT_AUTO_REPLACE, TEXT_AUTO_REPLACE_VALIDATOR)3420 VALIDATORS.put(TEXT_AUTO_REPLACE, TEXT_AUTO_REPLACE_VALIDATOR); VALIDATORS.put(TEXT_AUTO_CAPS, TEXT_AUTO_CAPS_VALIDATOR)3421 VALIDATORS.put(TEXT_AUTO_CAPS, TEXT_AUTO_CAPS_VALIDATOR); VALIDATORS.put(TEXT_AUTO_PUNCTUATE, TEXT_AUTO_PUNCTUATE_VALIDATOR)3422 VALIDATORS.put(TEXT_AUTO_PUNCTUATE, TEXT_AUTO_PUNCTUATE_VALIDATOR); VALIDATORS.put(TEXT_SHOW_PASSWORD, TEXT_SHOW_PASSWORD_VALIDATOR)3423 VALIDATORS.put(TEXT_SHOW_PASSWORD, TEXT_SHOW_PASSWORD_VALIDATOR); VALIDATORS.put(SHOW_GTALK_SERVICE_STATUS, SHOW_GTALK_SERVICE_STATUS_VALIDATOR)3424 VALIDATORS.put(SHOW_GTALK_SERVICE_STATUS, SHOW_GTALK_SERVICE_STATUS_VALIDATOR); VALIDATORS.put(WALLPAPER_ACTIVITY, WALLPAPER_ACTIVITY_VALIDATOR)3425 VALIDATORS.put(WALLPAPER_ACTIVITY, WALLPAPER_ACTIVITY_VALIDATOR); VALIDATORS.put(TIME_12_24, TIME_12_24_VALIDATOR)3426 VALIDATORS.put(TIME_12_24, TIME_12_24_VALIDATOR); VALIDATORS.put(DATE_FORMAT, DATE_FORMAT_VALIDATOR)3427 VALIDATORS.put(DATE_FORMAT, DATE_FORMAT_VALIDATOR); VALIDATORS.put(SETUP_WIZARD_HAS_RUN, SETUP_WIZARD_HAS_RUN_VALIDATOR)3428 VALIDATORS.put(SETUP_WIZARD_HAS_RUN, SETUP_WIZARD_HAS_RUN_VALIDATOR); VALIDATORS.put(ACCELEROMETER_ROTATION, ACCELEROMETER_ROTATION_VALIDATOR)3429 VALIDATORS.put(ACCELEROMETER_ROTATION, ACCELEROMETER_ROTATION_VALIDATOR); VALIDATORS.put(USER_ROTATION, USER_ROTATION_VALIDATOR)3430 VALIDATORS.put(USER_ROTATION, USER_ROTATION_VALIDATOR); VALIDATORS.put(DTMF_TONE_WHEN_DIALING, DTMF_TONE_WHEN_DIALING_VALIDATOR)3431 VALIDATORS.put(DTMF_TONE_WHEN_DIALING, DTMF_TONE_WHEN_DIALING_VALIDATOR); VALIDATORS.put(SOUND_EFFECTS_ENABLED, SOUND_EFFECTS_ENABLED_VALIDATOR)3432 VALIDATORS.put(SOUND_EFFECTS_ENABLED, SOUND_EFFECTS_ENABLED_VALIDATOR); VALIDATORS.put(HAPTIC_FEEDBACK_ENABLED, HAPTIC_FEEDBACK_ENABLED_VALIDATOR)3433 VALIDATORS.put(HAPTIC_FEEDBACK_ENABLED, HAPTIC_FEEDBACK_ENABLED_VALIDATOR); VALIDATORS.put(SHOW_WEB_SUGGESTIONS, SHOW_WEB_SUGGESTIONS_VALIDATOR)3434 VALIDATORS.put(SHOW_WEB_SUGGESTIONS, SHOW_WEB_SUGGESTIONS_VALIDATOR); VALIDATORS.put(WIFI_USE_STATIC_IP, WIFI_USE_STATIC_IP_VALIDATOR)3435 VALIDATORS.put(WIFI_USE_STATIC_IP, WIFI_USE_STATIC_IP_VALIDATOR); VALIDATORS.put(END_BUTTON_BEHAVIOR, END_BUTTON_BEHAVIOR_VALIDATOR)3436 VALIDATORS.put(END_BUTTON_BEHAVIOR, END_BUTTON_BEHAVIOR_VALIDATOR); VALIDATORS.put(ADVANCED_SETTINGS, ADVANCED_SETTINGS_VALIDATOR)3437 VALIDATORS.put(ADVANCED_SETTINGS, ADVANCED_SETTINGS_VALIDATOR); VALIDATORS.put(SCREEN_AUTO_BRIGHTNESS_ADJ, SCREEN_AUTO_BRIGHTNESS_ADJ_VALIDATOR)3438 VALIDATORS.put(SCREEN_AUTO_BRIGHTNESS_ADJ, SCREEN_AUTO_BRIGHTNESS_ADJ_VALIDATOR); VALIDATORS.put(VIBRATE_INPUT_DEVICES, VIBRATE_INPUT_DEVICES_VALIDATOR)3439 VALIDATORS.put(VIBRATE_INPUT_DEVICES, VIBRATE_INPUT_DEVICES_VALIDATOR); VALIDATORS.put(VOLUME_MASTER_MUTE, VOLUME_MASTER_MUTE_VALIDATOR)3440 VALIDATORS.put(VOLUME_MASTER_MUTE, VOLUME_MASTER_MUTE_VALIDATOR); VALIDATORS.put(MICROPHONE_MUTE, MICROPHONE_MUTE_VALIDATOR)3441 VALIDATORS.put(MICROPHONE_MUTE, MICROPHONE_MUTE_VALIDATOR); VALIDATORS.put(NOTIFICATIONS_USE_RING_VOLUME, NOTIFICATIONS_USE_RING_VOLUME_VALIDATOR)3442 VALIDATORS.put(NOTIFICATIONS_USE_RING_VOLUME, NOTIFICATIONS_USE_RING_VOLUME_VALIDATOR); VALIDATORS.put(VIBRATE_IN_SILENT, VIBRATE_IN_SILENT_VALIDATOR)3443 VALIDATORS.put(VIBRATE_IN_SILENT, VIBRATE_IN_SILENT_VALIDATOR); VALIDATORS.put(MEDIA_BUTTON_RECEIVER, MEDIA_BUTTON_RECEIVER_VALIDATOR)3444 VALIDATORS.put(MEDIA_BUTTON_RECEIVER, MEDIA_BUTTON_RECEIVER_VALIDATOR); VALIDATORS.put(HIDE_ROTATION_LOCK_TOGGLE_FOR_ACCESSIBILITY, HIDE_ROTATION_LOCK_TOGGLE_FOR_ACCESSIBILITY_VALIDATOR)3445 VALIDATORS.put(HIDE_ROTATION_LOCK_TOGGLE_FOR_ACCESSIBILITY, 3446 HIDE_ROTATION_LOCK_TOGGLE_FOR_ACCESSIBILITY_VALIDATOR); VALIDATORS.put(VIBRATE_WHEN_RINGING, VIBRATE_WHEN_RINGING_VALIDATOR)3447 VALIDATORS.put(VIBRATE_WHEN_RINGING, VIBRATE_WHEN_RINGING_VALIDATOR); VALIDATORS.put(DTMF_TONE_TYPE_WHEN_DIALING, DTMF_TONE_TYPE_WHEN_DIALING_VALIDATOR)3448 VALIDATORS.put(DTMF_TONE_TYPE_WHEN_DIALING, DTMF_TONE_TYPE_WHEN_DIALING_VALIDATOR); VALIDATORS.put(HEARING_AID, HEARING_AID_VALIDATOR)3449 VALIDATORS.put(HEARING_AID, HEARING_AID_VALIDATOR); VALIDATORS.put(TTY_MODE, TTY_MODE_VALIDATOR)3450 VALIDATORS.put(TTY_MODE, TTY_MODE_VALIDATOR); VALIDATORS.put(NOTIFICATION_LIGHT_PULSE, NOTIFICATION_LIGHT_PULSE_VALIDATOR)3451 VALIDATORS.put(NOTIFICATION_LIGHT_PULSE, NOTIFICATION_LIGHT_PULSE_VALIDATOR); VALIDATORS.put(POINTER_LOCATION, POINTER_LOCATION_VALIDATOR)3452 VALIDATORS.put(POINTER_LOCATION, POINTER_LOCATION_VALIDATOR); VALIDATORS.put(SHOW_TOUCHES, SHOW_TOUCHES_VALIDATOR)3453 VALIDATORS.put(SHOW_TOUCHES, SHOW_TOUCHES_VALIDATOR); VALIDATORS.put(WINDOW_ORIENTATION_LISTENER_LOG, WINDOW_ORIENTATION_LISTENER_LOG_VALIDATOR)3454 VALIDATORS.put(WINDOW_ORIENTATION_LISTENER_LOG, 3455 WINDOW_ORIENTATION_LISTENER_LOG_VALIDATOR); VALIDATORS.put(LOCKSCREEN_SOUNDS_ENABLED, LOCKSCREEN_SOUNDS_ENABLED_VALIDATOR)3456 VALIDATORS.put(LOCKSCREEN_SOUNDS_ENABLED, LOCKSCREEN_SOUNDS_ENABLED_VALIDATOR); VALIDATORS.put(LOCKSCREEN_DISABLED, LOCKSCREEN_DISABLED_VALIDATOR)3457 VALIDATORS.put(LOCKSCREEN_DISABLED, LOCKSCREEN_DISABLED_VALIDATOR); VALIDATORS.put(SIP_RECEIVE_CALLS, SIP_RECEIVE_CALLS_VALIDATOR)3458 VALIDATORS.put(SIP_RECEIVE_CALLS, SIP_RECEIVE_CALLS_VALIDATOR); VALIDATORS.put(SIP_CALL_OPTIONS, SIP_CALL_OPTIONS_VALIDATOR)3459 VALIDATORS.put(SIP_CALL_OPTIONS, SIP_CALL_OPTIONS_VALIDATOR); VALIDATORS.put(SIP_ALWAYS, SIP_ALWAYS_VALIDATOR)3460 VALIDATORS.put(SIP_ALWAYS, SIP_ALWAYS_VALIDATOR); VALIDATORS.put(SIP_ADDRESS_ONLY, SIP_ADDRESS_ONLY_VALIDATOR)3461 VALIDATORS.put(SIP_ADDRESS_ONLY, SIP_ADDRESS_ONLY_VALIDATOR); VALIDATORS.put(SIP_ASK_ME_EACH_TIME, SIP_ASK_ME_EACH_TIME_VALIDATOR)3462 VALIDATORS.put(SIP_ASK_ME_EACH_TIME, SIP_ASK_ME_EACH_TIME_VALIDATOR); VALIDATORS.put(POINTER_SPEED, POINTER_SPEED_VALIDATOR)3463 VALIDATORS.put(POINTER_SPEED, POINTER_SPEED_VALIDATOR); VALIDATORS.put(LOCK_TO_APP_ENABLED, LOCK_TO_APP_ENABLED_VALIDATOR)3464 VALIDATORS.put(LOCK_TO_APP_ENABLED, LOCK_TO_APP_ENABLED_VALIDATOR); VALIDATORS.put(EGG_MODE, EGG_MODE_VALIDATOR)3465 VALIDATORS.put(EGG_MODE, EGG_MODE_VALIDATOR); VALIDATORS.put(WIFI_STATIC_IP, WIFI_STATIC_IP_VALIDATOR)3466 VALIDATORS.put(WIFI_STATIC_IP, WIFI_STATIC_IP_VALIDATOR); VALIDATORS.put(WIFI_STATIC_GATEWAY, WIFI_STATIC_GATEWAY_VALIDATOR)3467 VALIDATORS.put(WIFI_STATIC_GATEWAY, WIFI_STATIC_GATEWAY_VALIDATOR); VALIDATORS.put(WIFI_STATIC_NETMASK, WIFI_STATIC_NETMASK_VALIDATOR)3468 VALIDATORS.put(WIFI_STATIC_NETMASK, WIFI_STATIC_NETMASK_VALIDATOR); VALIDATORS.put(WIFI_STATIC_DNS1, WIFI_STATIC_DNS1_VALIDATOR)3469 VALIDATORS.put(WIFI_STATIC_DNS1, WIFI_STATIC_DNS1_VALIDATOR); VALIDATORS.put(WIFI_STATIC_DNS2, WIFI_STATIC_DNS2_VALIDATOR)3470 VALIDATORS.put(WIFI_STATIC_DNS2, WIFI_STATIC_DNS2_VALIDATOR); 3471 } 3472 3473 /** 3474 * These entries are considered common between the personal and the managed profile, 3475 * since the managed profile doesn't get to change them. 3476 */ 3477 private static final Set<String> CLONE_TO_MANAGED_PROFILE = new ArraySet<>(); 3478 static { 3479 CLONE_TO_MANAGED_PROFILE.add(DATE_FORMAT); 3480 CLONE_TO_MANAGED_PROFILE.add(HAPTIC_FEEDBACK_ENABLED); 3481 CLONE_TO_MANAGED_PROFILE.add(SOUND_EFFECTS_ENABLED); 3482 CLONE_TO_MANAGED_PROFILE.add(TEXT_SHOW_PASSWORD); 3483 CLONE_TO_MANAGED_PROFILE.add(TIME_12_24); 3484 } 3485 3486 /** @hide */ getCloneToManagedProfileSettings(Set<String> outKeySet)3487 public static void getCloneToManagedProfileSettings(Set<String> outKeySet) { 3488 outKeySet.addAll(CLONE_TO_MANAGED_PROFILE); 3489 } 3490 3491 /** 3492 * When to use Wi-Fi calling 3493 * 3494 * @see android.telephony.TelephonyManager.WifiCallingChoices 3495 * @hide 3496 */ 3497 public static final String WHEN_TO_MAKE_WIFI_CALLS = "when_to_make_wifi_calls"; 3498 3499 // Settings moved to Settings.Secure 3500 3501 /** 3502 * @deprecated Use {@link android.provider.Settings.Global#ADB_ENABLED} 3503 * instead 3504 */ 3505 @Deprecated 3506 public static final String ADB_ENABLED = Global.ADB_ENABLED; 3507 3508 /** 3509 * @deprecated Use {@link android.provider.Settings.Secure#ANDROID_ID} instead 3510 */ 3511 @Deprecated 3512 public static final String ANDROID_ID = Secure.ANDROID_ID; 3513 3514 /** 3515 * @deprecated Use {@link android.provider.Settings.Global#BLUETOOTH_ON} instead 3516 */ 3517 @Deprecated 3518 public static final String BLUETOOTH_ON = Global.BLUETOOTH_ON; 3519 3520 /** 3521 * @deprecated Use {@link android.provider.Settings.Global#DATA_ROAMING} instead 3522 */ 3523 @Deprecated 3524 public static final String DATA_ROAMING = Global.DATA_ROAMING; 3525 3526 /** 3527 * @deprecated Use {@link android.provider.Settings.Global#DEVICE_PROVISIONED} instead 3528 */ 3529 @Deprecated 3530 public static final String DEVICE_PROVISIONED = Global.DEVICE_PROVISIONED; 3531 3532 /** 3533 * @deprecated Use {@link android.provider.Settings.Global#HTTP_PROXY} instead 3534 */ 3535 @Deprecated 3536 public static final String HTTP_PROXY = Global.HTTP_PROXY; 3537 3538 /** 3539 * @deprecated Use {@link android.provider.Settings.Secure#INSTALL_NON_MARKET_APPS} instead 3540 */ 3541 @Deprecated 3542 public static final String INSTALL_NON_MARKET_APPS = Secure.INSTALL_NON_MARKET_APPS; 3543 3544 /** 3545 * @deprecated Use {@link android.provider.Settings.Secure#LOCATION_PROVIDERS_ALLOWED} 3546 * instead 3547 */ 3548 @Deprecated 3549 public static final String LOCATION_PROVIDERS_ALLOWED = Secure.LOCATION_PROVIDERS_ALLOWED; 3550 3551 /** 3552 * @deprecated Use {@link android.provider.Settings.Secure#LOGGING_ID} instead 3553 */ 3554 @Deprecated 3555 public static final String LOGGING_ID = Secure.LOGGING_ID; 3556 3557 /** 3558 * @deprecated Use {@link android.provider.Settings.Global#NETWORK_PREFERENCE} instead 3559 */ 3560 @Deprecated 3561 public static final String NETWORK_PREFERENCE = Global.NETWORK_PREFERENCE; 3562 3563 /** 3564 * @deprecated Use {@link android.provider.Settings.Secure#PARENTAL_CONTROL_ENABLED} 3565 * instead 3566 */ 3567 @Deprecated 3568 public static final String PARENTAL_CONTROL_ENABLED = Secure.PARENTAL_CONTROL_ENABLED; 3569 3570 /** 3571 * @deprecated Use {@link android.provider.Settings.Secure#PARENTAL_CONTROL_LAST_UPDATE} 3572 * instead 3573 */ 3574 @Deprecated 3575 public static final String PARENTAL_CONTROL_LAST_UPDATE = Secure.PARENTAL_CONTROL_LAST_UPDATE; 3576 3577 /** 3578 * @deprecated Use {@link android.provider.Settings.Secure#PARENTAL_CONTROL_REDIRECT_URL} 3579 * instead 3580 */ 3581 @Deprecated 3582 public static final String PARENTAL_CONTROL_REDIRECT_URL = 3583 Secure.PARENTAL_CONTROL_REDIRECT_URL; 3584 3585 /** 3586 * @deprecated Use {@link android.provider.Settings.Secure#SETTINGS_CLASSNAME} instead 3587 */ 3588 @Deprecated 3589 public static final String SETTINGS_CLASSNAME = Secure.SETTINGS_CLASSNAME; 3590 3591 /** 3592 * @deprecated Use {@link android.provider.Settings.Global#USB_MASS_STORAGE_ENABLED} instead 3593 */ 3594 @Deprecated 3595 public static final String USB_MASS_STORAGE_ENABLED = Global.USB_MASS_STORAGE_ENABLED; 3596 3597 /** 3598 * @deprecated Use {@link android.provider.Settings.Global#USE_GOOGLE_MAIL} instead 3599 */ 3600 @Deprecated 3601 public static final String USE_GOOGLE_MAIL = Global.USE_GOOGLE_MAIL; 3602 3603 /** 3604 * @deprecated Use 3605 * {@link android.provider.Settings.Global#WIFI_MAX_DHCP_RETRY_COUNT} instead 3606 */ 3607 @Deprecated 3608 public static final String WIFI_MAX_DHCP_RETRY_COUNT = Global.WIFI_MAX_DHCP_RETRY_COUNT; 3609 3610 /** 3611 * @deprecated Use 3612 * {@link android.provider.Settings.Global#WIFI_MOBILE_DATA_TRANSITION_WAKELOCK_TIMEOUT_MS} instead 3613 */ 3614 @Deprecated 3615 public static final String WIFI_MOBILE_DATA_TRANSITION_WAKELOCK_TIMEOUT_MS = 3616 Global.WIFI_MOBILE_DATA_TRANSITION_WAKELOCK_TIMEOUT_MS; 3617 3618 /** 3619 * @deprecated Use 3620 * {@link android.provider.Settings.Global#WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON} instead 3621 */ 3622 @Deprecated 3623 public static final String WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON = 3624 Global.WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON; 3625 3626 /** 3627 * @deprecated Use 3628 * {@link android.provider.Settings.Global#WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY} instead 3629 */ 3630 @Deprecated 3631 public static final String WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY = 3632 Global.WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY; 3633 3634 /** 3635 * @deprecated Use {@link android.provider.Settings.Global#WIFI_NUM_OPEN_NETWORKS_KEPT} 3636 * instead 3637 */ 3638 @Deprecated 3639 public static final String WIFI_NUM_OPEN_NETWORKS_KEPT = Global.WIFI_NUM_OPEN_NETWORKS_KEPT; 3640 3641 /** 3642 * @deprecated Use {@link android.provider.Settings.Global#WIFI_ON} instead 3643 */ 3644 @Deprecated 3645 public static final String WIFI_ON = Global.WIFI_ON; 3646 3647 /** 3648 * @deprecated Use 3649 * {@link android.provider.Settings.Secure#WIFI_WATCHDOG_ACCEPTABLE_PACKET_LOSS_PERCENTAGE} 3650 * instead 3651 */ 3652 @Deprecated 3653 public static final String WIFI_WATCHDOG_ACCEPTABLE_PACKET_LOSS_PERCENTAGE = 3654 Secure.WIFI_WATCHDOG_ACCEPTABLE_PACKET_LOSS_PERCENTAGE; 3655 3656 /** 3657 * @deprecated Use {@link android.provider.Settings.Secure#WIFI_WATCHDOG_AP_COUNT} instead 3658 */ 3659 @Deprecated 3660 public static final String WIFI_WATCHDOG_AP_COUNT = Secure.WIFI_WATCHDOG_AP_COUNT; 3661 3662 /** 3663 * @deprecated Use 3664 * {@link android.provider.Settings.Secure#WIFI_WATCHDOG_BACKGROUND_CHECK_DELAY_MS} instead 3665 */ 3666 @Deprecated 3667 public static final String WIFI_WATCHDOG_BACKGROUND_CHECK_DELAY_MS = 3668 Secure.WIFI_WATCHDOG_BACKGROUND_CHECK_DELAY_MS; 3669 3670 /** 3671 * @deprecated Use 3672 * {@link android.provider.Settings.Secure#WIFI_WATCHDOG_BACKGROUND_CHECK_ENABLED} instead 3673 */ 3674 @Deprecated 3675 public static final String WIFI_WATCHDOG_BACKGROUND_CHECK_ENABLED = 3676 Secure.WIFI_WATCHDOG_BACKGROUND_CHECK_ENABLED; 3677 3678 /** 3679 * @deprecated Use 3680 * {@link android.provider.Settings.Secure#WIFI_WATCHDOG_BACKGROUND_CHECK_TIMEOUT_MS} 3681 * instead 3682 */ 3683 @Deprecated 3684 public static final String WIFI_WATCHDOG_BACKGROUND_CHECK_TIMEOUT_MS = 3685 Secure.WIFI_WATCHDOG_BACKGROUND_CHECK_TIMEOUT_MS; 3686 3687 /** 3688 * @deprecated Use 3689 * {@link android.provider.Settings.Secure#WIFI_WATCHDOG_INITIAL_IGNORED_PING_COUNT} instead 3690 */ 3691 @Deprecated 3692 public static final String WIFI_WATCHDOG_INITIAL_IGNORED_PING_COUNT = 3693 Secure.WIFI_WATCHDOG_INITIAL_IGNORED_PING_COUNT; 3694 3695 /** 3696 * @deprecated Use {@link android.provider.Settings.Secure#WIFI_WATCHDOG_MAX_AP_CHECKS} 3697 * instead 3698 */ 3699 @Deprecated 3700 public static final String WIFI_WATCHDOG_MAX_AP_CHECKS = Secure.WIFI_WATCHDOG_MAX_AP_CHECKS; 3701 3702 /** 3703 * @deprecated Use {@link android.provider.Settings.Global#WIFI_WATCHDOG_ON} instead 3704 */ 3705 @Deprecated 3706 public static final String WIFI_WATCHDOG_ON = Global.WIFI_WATCHDOG_ON; 3707 3708 /** 3709 * @deprecated Use {@link android.provider.Settings.Secure#WIFI_WATCHDOG_PING_COUNT} instead 3710 */ 3711 @Deprecated 3712 public static final String WIFI_WATCHDOG_PING_COUNT = Secure.WIFI_WATCHDOG_PING_COUNT; 3713 3714 /** 3715 * @deprecated Use {@link android.provider.Settings.Secure#WIFI_WATCHDOG_PING_DELAY_MS} 3716 * instead 3717 */ 3718 @Deprecated 3719 public static final String WIFI_WATCHDOG_PING_DELAY_MS = Secure.WIFI_WATCHDOG_PING_DELAY_MS; 3720 3721 /** 3722 * @deprecated Use {@link android.provider.Settings.Secure#WIFI_WATCHDOG_PING_TIMEOUT_MS} 3723 * instead 3724 */ 3725 @Deprecated 3726 public static final String WIFI_WATCHDOG_PING_TIMEOUT_MS = 3727 Secure.WIFI_WATCHDOG_PING_TIMEOUT_MS; 3728 3729 /** 3730 * An app can use this method to check if it is currently allowed to write or modify system 3731 * settings. In order to gain write access to the system settings, an app must declare the 3732 * {@link android.Manifest.permission#WRITE_SETTINGS} permission in its manifest. If it is 3733 * currently disallowed, it can prompt the user to grant it this capability through a 3734 * management UI by sending an Intent with action 3735 * {@link android.provider.Settings#ACTION_MANAGE_WRITE_SETTINGS}. 3736 * 3737 * @param context A context 3738 * @return true if the calling app can write to system settings, false otherwise 3739 */ canWrite(Context context)3740 public static boolean canWrite(Context context) { 3741 int uid = Binder.getCallingUid(); 3742 return isCallingPackageAllowedToWriteSettings(context, uid, getPackageNameForUid( 3743 context, uid), false); 3744 } 3745 } 3746 3747 /** 3748 * Secure system settings, containing system preferences that applications 3749 * can read but are not allowed to write. These are for preferences that 3750 * the user must explicitly modify through the system UI or specialized 3751 * APIs for those values, not modified directly by applications. 3752 */ 3753 public static final class Secure extends NameValueTable { 3754 public static final String SYS_PROP_SETTING_VERSION = "sys.settings_secure_version"; 3755 3756 /** 3757 * The content:// style URL for this table 3758 */ 3759 public static final Uri CONTENT_URI = 3760 Uri.parse("content://" + AUTHORITY + "/secure"); 3761 3762 // Populated lazily, guarded by class object: 3763 private static final NameValueCache sNameValueCache = new NameValueCache( 3764 SYS_PROP_SETTING_VERSION, 3765 CONTENT_URI, 3766 CALL_METHOD_GET_SECURE, 3767 CALL_METHOD_PUT_SECURE); 3768 3769 private static ILockSettings sLockSettings = null; 3770 3771 private static boolean sIsSystemProcess; 3772 private static final HashSet<String> MOVED_TO_LOCK_SETTINGS; 3773 private static final HashSet<String> MOVED_TO_GLOBAL; 3774 static { 3775 MOVED_TO_LOCK_SETTINGS = new HashSet<String>(3); 3776 MOVED_TO_LOCK_SETTINGS.add(Secure.LOCK_PATTERN_ENABLED); 3777 MOVED_TO_LOCK_SETTINGS.add(Secure.LOCK_PATTERN_VISIBLE); 3778 MOVED_TO_LOCK_SETTINGS.add(Secure.LOCK_PATTERN_TACTILE_FEEDBACK_ENABLED); 3779 3780 MOVED_TO_GLOBAL = new HashSet<String>(); 3781 MOVED_TO_GLOBAL.add(Settings.Global.ADB_ENABLED); 3782 MOVED_TO_GLOBAL.add(Settings.Global.ASSISTED_GPS_ENABLED); 3783 MOVED_TO_GLOBAL.add(Settings.Global.BLUETOOTH_ON); 3784 MOVED_TO_GLOBAL.add(Settings.Global.BUGREPORT_IN_POWER_MENU); 3785 MOVED_TO_GLOBAL.add(Settings.Global.CDMA_CELL_BROADCAST_SMS); 3786 MOVED_TO_GLOBAL.add(Settings.Global.CDMA_ROAMING_MODE); 3787 MOVED_TO_GLOBAL.add(Settings.Global.CDMA_SUBSCRIPTION_MODE); 3788 MOVED_TO_GLOBAL.add(Settings.Global.DATA_ACTIVITY_TIMEOUT_MOBILE); 3789 MOVED_TO_GLOBAL.add(Settings.Global.DATA_ACTIVITY_TIMEOUT_WIFI); 3790 MOVED_TO_GLOBAL.add(Settings.Global.DATA_ROAMING); 3791 MOVED_TO_GLOBAL.add(Settings.Global.DEVELOPMENT_SETTINGS_ENABLED); 3792 MOVED_TO_GLOBAL.add(Settings.Global.DEVICE_PROVISIONED); 3793 MOVED_TO_GLOBAL.add(Settings.Global.DISPLAY_DENSITY_FORCED); 3794 MOVED_TO_GLOBAL.add(Settings.Global.DISPLAY_SIZE_FORCED); 3795 MOVED_TO_GLOBAL.add(Settings.Global.DOWNLOAD_MAX_BYTES_OVER_MOBILE); 3796 MOVED_TO_GLOBAL.add(Settings.Global.DOWNLOAD_RECOMMENDED_MAX_BYTES_OVER_MOBILE); 3797 MOVED_TO_GLOBAL.add(Settings.Global.MOBILE_DATA); 3798 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_DEV_BUCKET_DURATION); 3799 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_DEV_DELETE_AGE); 3800 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_DEV_PERSIST_BYTES); 3801 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_DEV_ROTATE_AGE); 3802 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_ENABLED); 3803 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_GLOBAL_ALERT_BYTES); 3804 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_POLL_INTERVAL); 3805 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_SAMPLE_ENABLED); 3806 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_TIME_CACHE_MAX_AGE); 3807 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_UID_BUCKET_DURATION); 3808 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_UID_DELETE_AGE); 3809 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_UID_PERSIST_BYTES); 3810 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_UID_ROTATE_AGE); 3811 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_UID_TAG_BUCKET_DURATION); 3812 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_UID_TAG_DELETE_AGE); 3813 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_UID_TAG_PERSIST_BYTES); 3814 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_UID_TAG_ROTATE_AGE); 3815 MOVED_TO_GLOBAL.add(Settings.Global.NETWORK_PREFERENCE); 3816 MOVED_TO_GLOBAL.add(Settings.Global.NITZ_UPDATE_DIFF); 3817 MOVED_TO_GLOBAL.add(Settings.Global.NITZ_UPDATE_SPACING); 3818 MOVED_TO_GLOBAL.add(Settings.Global.NTP_SERVER); 3819 MOVED_TO_GLOBAL.add(Settings.Global.NTP_TIMEOUT); 3820 MOVED_TO_GLOBAL.add(Settings.Global.PDP_WATCHDOG_ERROR_POLL_COUNT); 3821 MOVED_TO_GLOBAL.add(Settings.Global.PDP_WATCHDOG_LONG_POLL_INTERVAL_MS); 3822 MOVED_TO_GLOBAL.add(Settings.Global.PDP_WATCHDOG_MAX_PDP_RESET_FAIL_COUNT); 3823 MOVED_TO_GLOBAL.add(Settings.Global.PDP_WATCHDOG_POLL_INTERVAL_MS); 3824 MOVED_TO_GLOBAL.add(Settings.Global.PDP_WATCHDOG_TRIGGER_PACKET_COUNT); 3825 MOVED_TO_GLOBAL.add(Settings.Global.SAMPLING_PROFILER_MS); 3826 MOVED_TO_GLOBAL.add(Settings.Global.SETUP_PREPAID_DATA_SERVICE_URL); 3827 MOVED_TO_GLOBAL.add(Settings.Global.SETUP_PREPAID_DETECTION_REDIR_HOST); 3828 MOVED_TO_GLOBAL.add(Settings.Global.SETUP_PREPAID_DETECTION_TARGET_URL); 3829 MOVED_TO_GLOBAL.add(Settings.Global.TETHER_DUN_APN); 3830 MOVED_TO_GLOBAL.add(Settings.Global.TETHER_DUN_REQUIRED); 3831 MOVED_TO_GLOBAL.add(Settings.Global.TETHER_SUPPORTED); 3832 MOVED_TO_GLOBAL.add(Settings.Global.USB_MASS_STORAGE_ENABLED); 3833 MOVED_TO_GLOBAL.add(Settings.Global.USE_GOOGLE_MAIL); 3834 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_COUNTRY_CODE); 3835 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_FRAMEWORK_SCAN_INTERVAL_MS); 3836 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_FREQUENCY_BAND); 3837 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_IDLE_MS); 3838 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_MAX_DHCP_RETRY_COUNT); 3839 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_MOBILE_DATA_TRANSITION_WAKELOCK_TIMEOUT_MS); 3840 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON); 3841 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY); 3842 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_NUM_OPEN_NETWORKS_KEPT); 3843 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_ON); 3844 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_P2P_DEVICE_NAME); 3845 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_SAVED_STATE); 3846 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_SUPPLICANT_SCAN_INTERVAL_MS); 3847 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_SUSPEND_OPTIMIZATIONS_ENABLED); 3848 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_ENHANCED_AUTO_JOIN); 3849 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_NETWORK_SHOW_RSSI); 3850 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_WATCHDOG_ON); 3851 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_WATCHDOG_POOR_NETWORK_TEST_ENABLED); 3852 MOVED_TO_GLOBAL.add(Settings.Global.WIMAX_NETWORKS_AVAILABLE_NOTIFICATION_ON); 3853 MOVED_TO_GLOBAL.add(Settings.Global.PACKAGE_VERIFIER_ENABLE); 3854 MOVED_TO_GLOBAL.add(Settings.Global.PACKAGE_VERIFIER_TIMEOUT); 3855 MOVED_TO_GLOBAL.add(Settings.Global.PACKAGE_VERIFIER_DEFAULT_RESPONSE); 3856 MOVED_TO_GLOBAL.add(Settings.Global.DATA_STALL_ALARM_NON_AGGRESSIVE_DELAY_IN_MS); 3857 MOVED_TO_GLOBAL.add(Settings.Global.DATA_STALL_ALARM_AGGRESSIVE_DELAY_IN_MS); 3858 MOVED_TO_GLOBAL.add(Settings.Global.GPRS_REGISTER_CHECK_PERIOD_MS); 3859 MOVED_TO_GLOBAL.add(Settings.Global.WTF_IS_FATAL); 3860 MOVED_TO_GLOBAL.add(Settings.Global.BATTERY_DISCHARGE_DURATION_THRESHOLD); 3861 MOVED_TO_GLOBAL.add(Settings.Global.BATTERY_DISCHARGE_THRESHOLD); 3862 MOVED_TO_GLOBAL.add(Settings.Global.SEND_ACTION_APP_ERROR); 3863 MOVED_TO_GLOBAL.add(Settings.Global.DROPBOX_AGE_SECONDS); 3864 MOVED_TO_GLOBAL.add(Settings.Global.DROPBOX_MAX_FILES); 3865 MOVED_TO_GLOBAL.add(Settings.Global.DROPBOX_QUOTA_KB); 3866 MOVED_TO_GLOBAL.add(Settings.Global.DROPBOX_QUOTA_PERCENT); 3867 MOVED_TO_GLOBAL.add(Settings.Global.DROPBOX_RESERVE_PERCENT); 3868 MOVED_TO_GLOBAL.add(Settings.Global.DROPBOX_TAG_PREFIX); 3869 MOVED_TO_GLOBAL.add(Settings.Global.ERROR_LOGCAT_PREFIX); 3870 MOVED_TO_GLOBAL.add(Settings.Global.SYS_FREE_STORAGE_LOG_INTERVAL); 3871 MOVED_TO_GLOBAL.add(Settings.Global.DISK_FREE_CHANGE_REPORTING_THRESHOLD); 3872 MOVED_TO_GLOBAL.add(Settings.Global.SYS_STORAGE_THRESHOLD_PERCENTAGE); 3873 MOVED_TO_GLOBAL.add(Settings.Global.SYS_STORAGE_THRESHOLD_MAX_BYTES); 3874 MOVED_TO_GLOBAL.add(Settings.Global.SYS_STORAGE_FULL_THRESHOLD_BYTES); 3875 MOVED_TO_GLOBAL.add(Settings.Global.SYNC_MAX_RETRY_DELAY_IN_SECONDS); 3876 MOVED_TO_GLOBAL.add(Settings.Global.CONNECTIVITY_CHANGE_DELAY); 3877 MOVED_TO_GLOBAL.add(Settings.Global.CAPTIVE_PORTAL_DETECTION_ENABLED); 3878 MOVED_TO_GLOBAL.add(Settings.Global.CAPTIVE_PORTAL_SERVER); 3879 MOVED_TO_GLOBAL.add(Settings.Global.NSD_ON); 3880 MOVED_TO_GLOBAL.add(Settings.Global.SET_INSTALL_LOCATION); 3881 MOVED_TO_GLOBAL.add(Settings.Global.DEFAULT_INSTALL_LOCATION); 3882 MOVED_TO_GLOBAL.add(Settings.Global.INET_CONDITION_DEBOUNCE_UP_DELAY); 3883 MOVED_TO_GLOBAL.add(Settings.Global.INET_CONDITION_DEBOUNCE_DOWN_DELAY); 3884 MOVED_TO_GLOBAL.add(Settings.Global.READ_EXTERNAL_STORAGE_ENFORCED_DEFAULT); 3885 MOVED_TO_GLOBAL.add(Settings.Global.HTTP_PROXY); 3886 MOVED_TO_GLOBAL.add(Settings.Global.GLOBAL_HTTP_PROXY_HOST); 3887 MOVED_TO_GLOBAL.add(Settings.Global.GLOBAL_HTTP_PROXY_PORT); 3888 MOVED_TO_GLOBAL.add(Settings.Global.GLOBAL_HTTP_PROXY_EXCLUSION_LIST); 3889 MOVED_TO_GLOBAL.add(Settings.Global.SET_GLOBAL_HTTP_PROXY); 3890 MOVED_TO_GLOBAL.add(Settings.Global.DEFAULT_DNS_SERVER); 3891 MOVED_TO_GLOBAL.add(Settings.Global.PREFERRED_NETWORK_MODE); 3892 MOVED_TO_GLOBAL.add(Settings.Global.WEBVIEW_DATA_REDUCTION_PROXY_KEY); 3893 } 3894 3895 /** @hide */ getMovedToGlobalSettings(Set<String> outKeySet)3896 public static void getMovedToGlobalSettings(Set<String> outKeySet) { 3897 outKeySet.addAll(MOVED_TO_GLOBAL); 3898 } 3899 3900 /** 3901 * Look up a name in the database. 3902 * @param resolver to access the database with 3903 * @param name to look up in the table 3904 * @return the corresponding value, or null if not present 3905 */ getString(ContentResolver resolver, String name)3906 public static String getString(ContentResolver resolver, String name) { 3907 return getStringForUser(resolver, name, UserHandle.myUserId()); 3908 } 3909 3910 /** @hide */ getStringForUser(ContentResolver resolver, String name, int userHandle)3911 public static String getStringForUser(ContentResolver resolver, String name, 3912 int userHandle) { 3913 if (MOVED_TO_GLOBAL.contains(name)) { 3914 Log.w(TAG, "Setting " + name + " has moved from android.provider.Settings.Secure" 3915 + " to android.provider.Settings.Global."); 3916 return Global.getStringForUser(resolver, name, userHandle); 3917 } 3918 3919 if (MOVED_TO_LOCK_SETTINGS.contains(name)) { 3920 synchronized (Secure.class) { 3921 if (sLockSettings == null) { 3922 sLockSettings = ILockSettings.Stub.asInterface( 3923 (IBinder) ServiceManager.getService("lock_settings")); 3924 sIsSystemProcess = Process.myUid() == Process.SYSTEM_UID; 3925 } 3926 } 3927 if (sLockSettings != null && !sIsSystemProcess) { 3928 // No context; use the ActivityThread's context as an approximation for 3929 // determining the target API level. 3930 Application application = ActivityThread.currentApplication(); 3931 3932 boolean isPreMnc = application != null 3933 && application.getApplicationInfo() != null 3934 && application.getApplicationInfo().targetSdkVersion 3935 <= VERSION_CODES.LOLLIPOP_MR1; 3936 if (isPreMnc) { 3937 try { 3938 return sLockSettings.getString(name, "0", userHandle); 3939 } catch (RemoteException re) { 3940 // Fall through 3941 } 3942 } else { 3943 throw new SecurityException("Settings.Secure." + name 3944 + " is deprecated and no longer accessible." 3945 + " See API documentation for potential replacements."); 3946 } 3947 } 3948 } 3949 3950 return sNameValueCache.getStringForUser(resolver, name, userHandle); 3951 } 3952 3953 /** 3954 * Store a name/value pair into the database. 3955 * @param resolver to access the database with 3956 * @param name to store 3957 * @param value to associate with the name 3958 * @return true if the value was set, false on database errors 3959 */ putString(ContentResolver resolver, String name, String value)3960 public static boolean putString(ContentResolver resolver, String name, String value) { 3961 return putStringForUser(resolver, name, value, UserHandle.myUserId()); 3962 } 3963 3964 /** @hide */ putStringForUser(ContentResolver resolver, String name, String value, int userHandle)3965 public static boolean putStringForUser(ContentResolver resolver, String name, String value, 3966 int userHandle) { 3967 if (LOCATION_MODE.equals(name)) { 3968 // HACK ALERT: temporary hack to work around b/10491283. 3969 // TODO: once b/10491283 fixed, remove this hack 3970 return setLocationModeForUser(resolver, Integer.parseInt(value), userHandle); 3971 } 3972 if (MOVED_TO_GLOBAL.contains(name)) { 3973 Log.w(TAG, "Setting " + name + " has moved from android.provider.Settings.System" 3974 + " to android.provider.Settings.Global"); 3975 return Global.putStringForUser(resolver, name, value, userHandle); 3976 } 3977 return sNameValueCache.putStringForUser(resolver, name, value, userHandle); 3978 } 3979 3980 /** 3981 * Construct the content URI for a particular name/value pair, 3982 * useful for monitoring changes with a ContentObserver. 3983 * @param name to look up in the table 3984 * @return the corresponding content URI, or null if not present 3985 */ getUriFor(String name)3986 public static Uri getUriFor(String name) { 3987 if (MOVED_TO_GLOBAL.contains(name)) { 3988 Log.w(TAG, "Setting " + name + " has moved from android.provider.Settings.Secure" 3989 + " to android.provider.Settings.Global, returning global URI."); 3990 return Global.getUriFor(Global.CONTENT_URI, name); 3991 } 3992 return getUriFor(CONTENT_URI, name); 3993 } 3994 3995 /** 3996 * Convenience function for retrieving a single secure settings value 3997 * as an integer. Note that internally setting values are always 3998 * stored as strings; this function converts the string to an integer 3999 * for you. The default value will be returned if the setting is 4000 * not defined or not an integer. 4001 * 4002 * @param cr The ContentResolver to access. 4003 * @param name The name of the setting to retrieve. 4004 * @param def Value to return if the setting is not defined. 4005 * 4006 * @return The setting's current value, or 'def' if it is not defined 4007 * or not a valid integer. 4008 */ getInt(ContentResolver cr, String name, int def)4009 public static int getInt(ContentResolver cr, String name, int def) { 4010 return getIntForUser(cr, name, def, UserHandle.myUserId()); 4011 } 4012 4013 /** @hide */ getIntForUser(ContentResolver cr, String name, int def, int userHandle)4014 public static int getIntForUser(ContentResolver cr, String name, int def, int userHandle) { 4015 if (LOCATION_MODE.equals(name)) { 4016 // HACK ALERT: temporary hack to work around b/10491283. 4017 // TODO: once b/10491283 fixed, remove this hack 4018 return getLocationModeForUser(cr, userHandle); 4019 } 4020 String v = getStringForUser(cr, name, userHandle); 4021 try { 4022 return v != null ? Integer.parseInt(v) : def; 4023 } catch (NumberFormatException e) { 4024 return def; 4025 } 4026 } 4027 4028 /** 4029 * Convenience function for retrieving a single secure settings value 4030 * as an integer. Note that internally setting values are always 4031 * stored as strings; this function converts the string to an integer 4032 * for you. 4033 * <p> 4034 * This version does not take a default value. If the setting has not 4035 * been set, or the string value is not a number, 4036 * it throws {@link SettingNotFoundException}. 4037 * 4038 * @param cr The ContentResolver to access. 4039 * @param name The name of the setting to retrieve. 4040 * 4041 * @throws SettingNotFoundException Thrown if a setting by the given 4042 * name can't be found or the setting value is not an integer. 4043 * 4044 * @return The setting's current value. 4045 */ getInt(ContentResolver cr, String name)4046 public static int getInt(ContentResolver cr, String name) 4047 throws SettingNotFoundException { 4048 return getIntForUser(cr, name, UserHandle.myUserId()); 4049 } 4050 4051 /** @hide */ getIntForUser(ContentResolver cr, String name, int userHandle)4052 public static int getIntForUser(ContentResolver cr, String name, int userHandle) 4053 throws SettingNotFoundException { 4054 if (LOCATION_MODE.equals(name)) { 4055 // HACK ALERT: temporary hack to work around b/10491283. 4056 // TODO: once b/10491283 fixed, remove this hack 4057 return getLocationModeForUser(cr, userHandle); 4058 } 4059 String v = getStringForUser(cr, name, userHandle); 4060 try { 4061 return Integer.parseInt(v); 4062 } catch (NumberFormatException e) { 4063 throw new SettingNotFoundException(name); 4064 } 4065 } 4066 4067 /** 4068 * Convenience function for updating a single settings value as an 4069 * integer. This will either create a new entry in the table if the 4070 * given name does not exist, or modify the value of the existing row 4071 * with that name. Note that internally setting values are always 4072 * stored as strings, so this function converts the given value to a 4073 * string before storing it. 4074 * 4075 * @param cr The ContentResolver to access. 4076 * @param name The name of the setting to modify. 4077 * @param value The new value for the setting. 4078 * @return true if the value was set, false on database errors 4079 */ putInt(ContentResolver cr, String name, int value)4080 public static boolean putInt(ContentResolver cr, String name, int value) { 4081 return putIntForUser(cr, name, value, UserHandle.myUserId()); 4082 } 4083 4084 /** @hide */ putIntForUser(ContentResolver cr, String name, int value, int userHandle)4085 public static boolean putIntForUser(ContentResolver cr, String name, int value, 4086 int userHandle) { 4087 return putStringForUser(cr, name, Integer.toString(value), userHandle); 4088 } 4089 4090 /** 4091 * Convenience function for retrieving a single secure settings value 4092 * as a {@code long}. Note that internally setting values are always 4093 * stored as strings; this function converts the string to a {@code long} 4094 * for you. The default value will be returned if the setting is 4095 * not defined or not a {@code long}. 4096 * 4097 * @param cr The ContentResolver to access. 4098 * @param name The name of the setting to retrieve. 4099 * @param def Value to return if the setting is not defined. 4100 * 4101 * @return The setting's current value, or 'def' if it is not defined 4102 * or not a valid {@code long}. 4103 */ getLong(ContentResolver cr, String name, long def)4104 public static long getLong(ContentResolver cr, String name, long def) { 4105 return getLongForUser(cr, name, def, UserHandle.myUserId()); 4106 } 4107 4108 /** @hide */ getLongForUser(ContentResolver cr, String name, long def, int userHandle)4109 public static long getLongForUser(ContentResolver cr, String name, long def, 4110 int userHandle) { 4111 String valString = getStringForUser(cr, name, userHandle); 4112 long value; 4113 try { 4114 value = valString != null ? Long.parseLong(valString) : def; 4115 } catch (NumberFormatException e) { 4116 value = def; 4117 } 4118 return value; 4119 } 4120 4121 /** 4122 * Convenience function for retrieving a single secure settings value 4123 * as a {@code long}. Note that internally setting values are always 4124 * stored as strings; this function converts the string to a {@code long} 4125 * for you. 4126 * <p> 4127 * This version does not take a default value. If the setting has not 4128 * been set, or the string value is not a number, 4129 * it throws {@link SettingNotFoundException}. 4130 * 4131 * @param cr The ContentResolver to access. 4132 * @param name The name of the setting to retrieve. 4133 * 4134 * @return The setting's current value. 4135 * @throws SettingNotFoundException Thrown if a setting by the given 4136 * name can't be found or the setting value is not an integer. 4137 */ getLong(ContentResolver cr, String name)4138 public static long getLong(ContentResolver cr, String name) 4139 throws SettingNotFoundException { 4140 return getLongForUser(cr, name, UserHandle.myUserId()); 4141 } 4142 4143 /** @hide */ getLongForUser(ContentResolver cr, String name, int userHandle)4144 public static long getLongForUser(ContentResolver cr, String name, int userHandle) 4145 throws SettingNotFoundException { 4146 String valString = getStringForUser(cr, name, userHandle); 4147 try { 4148 return Long.parseLong(valString); 4149 } catch (NumberFormatException e) { 4150 throw new SettingNotFoundException(name); 4151 } 4152 } 4153 4154 /** 4155 * Convenience function for updating a secure settings value as a long 4156 * integer. This will either create a new entry in the table if the 4157 * given name does not exist, or modify the value of the existing row 4158 * with that name. Note that internally setting values are always 4159 * stored as strings, so this function converts the given value to a 4160 * string before storing it. 4161 * 4162 * @param cr The ContentResolver to access. 4163 * @param name The name of the setting to modify. 4164 * @param value The new value for the setting. 4165 * @return true if the value was set, false on database errors 4166 */ putLong(ContentResolver cr, String name, long value)4167 public static boolean putLong(ContentResolver cr, String name, long value) { 4168 return putLongForUser(cr, name, value, UserHandle.myUserId()); 4169 } 4170 4171 /** @hide */ putLongForUser(ContentResolver cr, String name, long value, int userHandle)4172 public static boolean putLongForUser(ContentResolver cr, String name, long value, 4173 int userHandle) { 4174 return putStringForUser(cr, name, Long.toString(value), userHandle); 4175 } 4176 4177 /** 4178 * Convenience function for retrieving a single secure settings value 4179 * as a floating point number. Note that internally setting values are 4180 * always stored as strings; this function converts the string to an 4181 * float for you. The default value will be returned if the setting 4182 * is not defined or not a valid float. 4183 * 4184 * @param cr The ContentResolver to access. 4185 * @param name The name of the setting to retrieve. 4186 * @param def Value to return if the setting is not defined. 4187 * 4188 * @return The setting's current value, or 'def' if it is not defined 4189 * or not a valid float. 4190 */ getFloat(ContentResolver cr, String name, float def)4191 public static float getFloat(ContentResolver cr, String name, float def) { 4192 return getFloatForUser(cr, name, def, UserHandle.myUserId()); 4193 } 4194 4195 /** @hide */ getFloatForUser(ContentResolver cr, String name, float def, int userHandle)4196 public static float getFloatForUser(ContentResolver cr, String name, float def, 4197 int userHandle) { 4198 String v = getStringForUser(cr, name, userHandle); 4199 try { 4200 return v != null ? Float.parseFloat(v) : def; 4201 } catch (NumberFormatException e) { 4202 return def; 4203 } 4204 } 4205 4206 /** 4207 * Convenience function for retrieving a single secure settings value 4208 * as a float. Note that internally setting values are always 4209 * stored as strings; this function converts the string to a float 4210 * for you. 4211 * <p> 4212 * This version does not take a default value. If the setting has not 4213 * been set, or the string value is not a number, 4214 * it throws {@link SettingNotFoundException}. 4215 * 4216 * @param cr The ContentResolver to access. 4217 * @param name The name of the setting to retrieve. 4218 * 4219 * @throws SettingNotFoundException Thrown if a setting by the given 4220 * name can't be found or the setting value is not a float. 4221 * 4222 * @return The setting's current value. 4223 */ getFloat(ContentResolver cr, String name)4224 public static float getFloat(ContentResolver cr, String name) 4225 throws SettingNotFoundException { 4226 return getFloatForUser(cr, name, UserHandle.myUserId()); 4227 } 4228 4229 /** @hide */ getFloatForUser(ContentResolver cr, String name, int userHandle)4230 public static float getFloatForUser(ContentResolver cr, String name, int userHandle) 4231 throws SettingNotFoundException { 4232 String v = getStringForUser(cr, name, userHandle); 4233 if (v == null) { 4234 throw new SettingNotFoundException(name); 4235 } 4236 try { 4237 return Float.parseFloat(v); 4238 } catch (NumberFormatException e) { 4239 throw new SettingNotFoundException(name); 4240 } 4241 } 4242 4243 /** 4244 * Convenience function for updating a single settings value as a 4245 * floating point number. This will either create a new entry in the 4246 * table if the given name does not exist, or modify the value of the 4247 * existing row with that name. Note that internally setting values 4248 * are always stored as strings, so this function converts the given 4249 * value to a string before storing it. 4250 * 4251 * @param cr The ContentResolver to access. 4252 * @param name The name of the setting to modify. 4253 * @param value The new value for the setting. 4254 * @return true if the value was set, false on database errors 4255 */ putFloat(ContentResolver cr, String name, float value)4256 public static boolean putFloat(ContentResolver cr, String name, float value) { 4257 return putFloatForUser(cr, name, value, UserHandle.myUserId()); 4258 } 4259 4260 /** @hide */ putFloatForUser(ContentResolver cr, String name, float value, int userHandle)4261 public static boolean putFloatForUser(ContentResolver cr, String name, float value, 4262 int userHandle) { 4263 return putStringForUser(cr, name, Float.toString(value), userHandle); 4264 } 4265 4266 /** 4267 * @deprecated Use {@link android.provider.Settings.Global#DEVELOPMENT_SETTINGS_ENABLED} 4268 * instead 4269 */ 4270 @Deprecated 4271 public static final String DEVELOPMENT_SETTINGS_ENABLED = 4272 Global.DEVELOPMENT_SETTINGS_ENABLED; 4273 4274 /** 4275 * When the user has enable the option to have a "bug report" command 4276 * in the power menu. 4277 * @deprecated Use {@link android.provider.Settings.Global#BUGREPORT_IN_POWER_MENU} instead 4278 * @hide 4279 */ 4280 @Deprecated 4281 public static final String BUGREPORT_IN_POWER_MENU = "bugreport_in_power_menu"; 4282 4283 /** 4284 * @deprecated Use {@link android.provider.Settings.Global#ADB_ENABLED} instead 4285 */ 4286 @Deprecated 4287 public static final String ADB_ENABLED = Global.ADB_ENABLED; 4288 4289 /** 4290 * Setting to allow mock locations and location provider status to be injected into the 4291 * LocationManager service for testing purposes during application development. These 4292 * locations and status values override actual location and status information generated 4293 * by network, gps, or other location providers. 4294 * 4295 * @deprecated This settings is not used anymore. 4296 */ 4297 @Deprecated 4298 public static final String ALLOW_MOCK_LOCATION = "mock_location"; 4299 4300 /** 4301 * A 64-bit number (as a hex string) that is randomly 4302 * generated when the user first sets up the device and should remain 4303 * constant for the lifetime of the user's device. The value may 4304 * change if a factory reset is performed on the device. 4305 * <p class="note"><strong>Note:</strong> When a device has <a 4306 * href="{@docRoot}about/versions/android-4.2.html#MultipleUsers">multiple users</a> 4307 * (available on certain devices running Android 4.2 or higher), each user appears as a 4308 * completely separate device, so the {@code ANDROID_ID} value is unique to each 4309 * user.</p> 4310 */ 4311 public static final String ANDROID_ID = "android_id"; 4312 4313 /** 4314 * @deprecated Use {@link android.provider.Settings.Global#BLUETOOTH_ON} instead 4315 */ 4316 @Deprecated 4317 public static final String BLUETOOTH_ON = Global.BLUETOOTH_ON; 4318 4319 /** 4320 * @deprecated Use {@link android.provider.Settings.Global#DATA_ROAMING} instead 4321 */ 4322 @Deprecated 4323 public static final String DATA_ROAMING = Global.DATA_ROAMING; 4324 4325 /** 4326 * Setting to record the input method used by default, holding the ID 4327 * of the desired method. 4328 */ 4329 public static final String DEFAULT_INPUT_METHOD = "default_input_method"; 4330 4331 /** 4332 * Setting to record the input method subtype used by default, holding the ID 4333 * of the desired method. 4334 */ 4335 public static final String SELECTED_INPUT_METHOD_SUBTYPE = 4336 "selected_input_method_subtype"; 4337 4338 /** 4339 * Setting to record the history of input method subtype, holding the pair of ID of IME 4340 * and its last used subtype. 4341 * @hide 4342 */ 4343 public static final String INPUT_METHODS_SUBTYPE_HISTORY = 4344 "input_methods_subtype_history"; 4345 4346 /** 4347 * Setting to record the visibility of input method selector 4348 */ 4349 public static final String INPUT_METHOD_SELECTOR_VISIBILITY = 4350 "input_method_selector_visibility"; 4351 4352 /** 4353 * The currently selected voice interaction service flattened ComponentName. 4354 * @hide 4355 */ 4356 public static final String VOICE_INTERACTION_SERVICE = "voice_interaction_service"; 4357 4358 /** 4359 * bluetooth HCI snoop log configuration 4360 * @hide 4361 */ 4362 public static final String BLUETOOTH_HCI_LOG = 4363 "bluetooth_hci_log"; 4364 4365 /** 4366 * @deprecated Use {@link android.provider.Settings.Global#DEVICE_PROVISIONED} instead 4367 */ 4368 @Deprecated 4369 public static final String DEVICE_PROVISIONED = Global.DEVICE_PROVISIONED; 4370 4371 /** 4372 * Whether the current user has been set up via setup wizard (0 = false, 1 = true) 4373 * @hide 4374 */ 4375 public static final String USER_SETUP_COMPLETE = "user_setup_complete"; 4376 4377 /** 4378 * List of input methods that are currently enabled. This is a string 4379 * containing the IDs of all enabled input methods, each ID separated 4380 * by ':'. 4381 */ 4382 public static final String ENABLED_INPUT_METHODS = "enabled_input_methods"; 4383 4384 /** 4385 * List of system input methods that are currently disabled. This is a string 4386 * containing the IDs of all disabled input methods, each ID separated 4387 * by ':'. 4388 * @hide 4389 */ 4390 public static final String DISABLED_SYSTEM_INPUT_METHODS = "disabled_system_input_methods"; 4391 4392 /** 4393 * Whether to show the IME when a hard keyboard is connected. This is a boolean that 4394 * determines if the IME should be shown when a hard keyboard is attached. 4395 * @hide 4396 */ 4397 public static final String SHOW_IME_WITH_HARD_KEYBOARD = "show_ime_with_hard_keyboard"; 4398 4399 /** 4400 * Host name and port for global http proxy. Uses ':' seperator for 4401 * between host and port. 4402 * 4403 * @deprecated Use {@link Global#HTTP_PROXY} 4404 */ 4405 @Deprecated 4406 public static final String HTTP_PROXY = Global.HTTP_PROXY; 4407 4408 /** 4409 * Whether applications can be installed for this user via the system's 4410 * {@link Intent#ACTION_INSTALL_PACKAGE} mechanism. 4411 * 4412 * <p>1 = permit app installation via the system package installer intent 4413 * <p>0 = do not allow use of the package installer 4414 */ 4415 public static final String INSTALL_NON_MARKET_APPS = "install_non_market_apps"; 4416 4417 /** 4418 * Comma-separated list of location providers that activities may access. Do not rely on 4419 * this value being present in settings.db or on ContentObserver notifications on the 4420 * corresponding Uri. 4421 * 4422 * @deprecated use {@link #LOCATION_MODE} and 4423 * {@link LocationManager#MODE_CHANGED_ACTION} (or 4424 * {@link LocationManager#PROVIDERS_CHANGED_ACTION}) 4425 */ 4426 @Deprecated 4427 public static final String LOCATION_PROVIDERS_ALLOWED = "location_providers_allowed"; 4428 4429 /** 4430 * The degree of location access enabled by the user. 4431 * <p> 4432 * When used with {@link #putInt(ContentResolver, String, int)}, must be one of {@link 4433 * #LOCATION_MODE_HIGH_ACCURACY}, {@link #LOCATION_MODE_SENSORS_ONLY}, {@link 4434 * #LOCATION_MODE_BATTERY_SAVING}, or {@link #LOCATION_MODE_OFF}. When used with {@link 4435 * #getInt(ContentResolver, String)}, the caller must gracefully handle additional location 4436 * modes that might be added in the future. 4437 * <p> 4438 * Note: do not rely on this value being present in settings.db or on ContentObserver 4439 * notifications for the corresponding Uri. Use {@link LocationManager#MODE_CHANGED_ACTION} 4440 * to receive changes in this value. 4441 */ 4442 public static final String LOCATION_MODE = "location_mode"; 4443 4444 /** 4445 * Location access disabled. 4446 */ 4447 public static final int LOCATION_MODE_OFF = 0; 4448 /** 4449 * Network Location Provider disabled, but GPS and other sensors enabled. 4450 */ 4451 public static final int LOCATION_MODE_SENSORS_ONLY = 1; 4452 /** 4453 * Reduced power usage, such as limiting the number of GPS updates per hour. Requests 4454 * with {@link android.location.Criteria#POWER_HIGH} may be downgraded to 4455 * {@link android.location.Criteria#POWER_MEDIUM}. 4456 */ 4457 public static final int LOCATION_MODE_BATTERY_SAVING = 2; 4458 /** 4459 * Best-effort location computation allowed. 4460 */ 4461 public static final int LOCATION_MODE_HIGH_ACCURACY = 3; 4462 4463 /** 4464 * A flag containing settings used for biometric weak 4465 * @hide 4466 */ 4467 @Deprecated 4468 public static final String LOCK_BIOMETRIC_WEAK_FLAGS = 4469 "lock_biometric_weak_flags"; 4470 4471 /** 4472 * Whether lock-to-app will lock the keyguard when exiting. 4473 * @hide 4474 */ 4475 public static final String LOCK_TO_APP_EXIT_LOCKED = "lock_to_app_exit_locked"; 4476 4477 /** 4478 * Whether autolock is enabled (0 = false, 1 = true) 4479 * 4480 * @deprecated Use {@link android.app.KeyguardManager} to determine the state and security 4481 * level of the keyguard. Accessing this setting from an app that is targeting 4482 * {@link VERSION_CODES#M} or later throws a {@code SecurityException}. 4483 */ 4484 @Deprecated 4485 public static final String LOCK_PATTERN_ENABLED = "lock_pattern_autolock"; 4486 4487 /** 4488 * Whether lock pattern is visible as user enters (0 = false, 1 = true) 4489 * 4490 * @deprecated Accessing this setting from an app that is targeting 4491 * {@link VERSION_CODES#M} or later throws a {@code SecurityException}. 4492 */ 4493 @Deprecated 4494 public static final String LOCK_PATTERN_VISIBLE = "lock_pattern_visible_pattern"; 4495 4496 /** 4497 * Whether lock pattern will vibrate as user enters (0 = false, 1 = 4498 * true) 4499 * 4500 * @deprecated Starting in {@link VERSION_CODES#JELLY_BEAN_MR1} the 4501 * lockscreen uses 4502 * {@link Settings.System#HAPTIC_FEEDBACK_ENABLED}. 4503 * Accessing this setting from an app that is targeting 4504 * {@link VERSION_CODES#M} or later throws a {@code SecurityException}. 4505 */ 4506 @Deprecated 4507 public static final String 4508 LOCK_PATTERN_TACTILE_FEEDBACK_ENABLED = "lock_pattern_tactile_feedback_enabled"; 4509 4510 /** 4511 * This preference allows the device to be locked given time after screen goes off, 4512 * subject to current DeviceAdmin policy limits. 4513 * @hide 4514 */ 4515 public static final String LOCK_SCREEN_LOCK_AFTER_TIMEOUT = "lock_screen_lock_after_timeout"; 4516 4517 4518 /** 4519 * This preference contains the string that shows for owner info on LockScreen. 4520 * @hide 4521 * @deprecated 4522 */ 4523 public static final String LOCK_SCREEN_OWNER_INFO = "lock_screen_owner_info"; 4524 4525 /** 4526 * Ids of the user-selected appwidgets on the lockscreen (comma-delimited). 4527 * @hide 4528 */ 4529 @Deprecated 4530 public static final String LOCK_SCREEN_APPWIDGET_IDS = 4531 "lock_screen_appwidget_ids"; 4532 4533 /** 4534 * Id of the appwidget shown on the lock screen when appwidgets are disabled. 4535 * @hide 4536 */ 4537 @Deprecated 4538 public static final String LOCK_SCREEN_FALLBACK_APPWIDGET_ID = 4539 "lock_screen_fallback_appwidget_id"; 4540 4541 /** 4542 * Index of the lockscreen appwidget to restore, -1 if none. 4543 * @hide 4544 */ 4545 @Deprecated 4546 public static final String LOCK_SCREEN_STICKY_APPWIDGET = 4547 "lock_screen_sticky_appwidget"; 4548 4549 /** 4550 * This preference enables showing the owner info on LockScreen. 4551 * @hide 4552 * @deprecated 4553 */ 4554 public static final String LOCK_SCREEN_OWNER_INFO_ENABLED = 4555 "lock_screen_owner_info_enabled"; 4556 4557 /** 4558 * When set by a user, allows notifications to be shown atop a securely locked screen 4559 * in their full "private" form (same as when the device is unlocked). 4560 * @hide 4561 */ 4562 public static final String LOCK_SCREEN_ALLOW_PRIVATE_NOTIFICATIONS = 4563 "lock_screen_allow_private_notifications"; 4564 4565 /** 4566 * Set by the system to track if the user needs to see the call to action for 4567 * the lockscreen notification policy. 4568 * @hide 4569 */ 4570 public static final String SHOW_NOTE_ABOUT_NOTIFICATION_HIDING = 4571 "show_note_about_notification_hiding"; 4572 4573 /** 4574 * Set to 1 by the system after trust agents have been initialized. 4575 * @hide 4576 */ 4577 public static final String TRUST_AGENTS_INITIALIZED = 4578 "trust_agents_initialized"; 4579 4580 /** 4581 * The Logging ID (a unique 64-bit value) as a hex string. 4582 * Used as a pseudonymous identifier for logging. 4583 * @deprecated This identifier is poorly initialized and has 4584 * many collisions. It should not be used. 4585 */ 4586 @Deprecated 4587 public static final String LOGGING_ID = "logging_id"; 4588 4589 /** 4590 * @deprecated Use {@link android.provider.Settings.Global#NETWORK_PREFERENCE} instead 4591 */ 4592 @Deprecated 4593 public static final String NETWORK_PREFERENCE = Global.NETWORK_PREFERENCE; 4594 4595 /** 4596 * No longer supported. 4597 */ 4598 public static final String PARENTAL_CONTROL_ENABLED = "parental_control_enabled"; 4599 4600 /** 4601 * No longer supported. 4602 */ 4603 public static final String PARENTAL_CONTROL_LAST_UPDATE = "parental_control_last_update"; 4604 4605 /** 4606 * No longer supported. 4607 */ 4608 public static final String PARENTAL_CONTROL_REDIRECT_URL = "parental_control_redirect_url"; 4609 4610 /** 4611 * Settings classname to launch when Settings is clicked from All 4612 * Applications. Needed because of user testing between the old 4613 * and new Settings apps. 4614 */ 4615 // TODO: 881807 4616 public static final String SETTINGS_CLASSNAME = "settings_classname"; 4617 4618 /** 4619 * @deprecated Use {@link android.provider.Settings.Global#USB_MASS_STORAGE_ENABLED} instead 4620 */ 4621 @Deprecated 4622 public static final String USB_MASS_STORAGE_ENABLED = Global.USB_MASS_STORAGE_ENABLED; 4623 4624 /** 4625 * @deprecated Use {@link android.provider.Settings.Global#USE_GOOGLE_MAIL} instead 4626 */ 4627 @Deprecated 4628 public static final String USE_GOOGLE_MAIL = Global.USE_GOOGLE_MAIL; 4629 4630 /** 4631 * If accessibility is enabled. 4632 */ 4633 public static final String ACCESSIBILITY_ENABLED = "accessibility_enabled"; 4634 4635 /** 4636 * If touch exploration is enabled. 4637 */ 4638 public static final String TOUCH_EXPLORATION_ENABLED = "touch_exploration_enabled"; 4639 4640 /** 4641 * List of the enabled accessibility providers. 4642 */ 4643 public static final String ENABLED_ACCESSIBILITY_SERVICES = 4644 "enabled_accessibility_services"; 4645 4646 /** 4647 * List of the accessibility services to which the user has granted 4648 * permission to put the device into touch exploration mode. 4649 * 4650 * @hide 4651 */ 4652 public static final String TOUCH_EXPLORATION_GRANTED_ACCESSIBILITY_SERVICES = 4653 "touch_exploration_granted_accessibility_services"; 4654 4655 /** 4656 * Whether to speak passwords while in accessibility mode. 4657 */ 4658 public static final String ACCESSIBILITY_SPEAK_PASSWORD = "speak_password"; 4659 4660 /** 4661 * Whether to draw text with high contrast while in accessibility mode. 4662 * 4663 * @hide 4664 */ 4665 public static final String ACCESSIBILITY_HIGH_TEXT_CONTRAST_ENABLED = 4666 "high_text_contrast_enabled"; 4667 4668 /** 4669 * If injection of accessibility enhancing JavaScript screen-reader 4670 * is enabled. 4671 * <p> 4672 * Note: The JavaScript based screen-reader is served by the 4673 * Google infrastructure and enable users with disabilities to 4674 * efficiently navigate in and explore web content. 4675 * </p> 4676 * <p> 4677 * This property represents a boolean value. 4678 * </p> 4679 * @hide 4680 */ 4681 public static final String ACCESSIBILITY_SCRIPT_INJECTION = 4682 "accessibility_script_injection"; 4683 4684 /** 4685 * The URL for the injected JavaScript based screen-reader used 4686 * for providing accessibility of content in WebView. 4687 * <p> 4688 * Note: The JavaScript based screen-reader is served by the 4689 * Google infrastructure and enable users with disabilities to 4690 * efficiently navigate in and explore web content. 4691 * </p> 4692 * <p> 4693 * This property represents a string value. 4694 * </p> 4695 * @hide 4696 */ 4697 public static final String ACCESSIBILITY_SCREEN_READER_URL = 4698 "accessibility_script_injection_url"; 4699 4700 /** 4701 * Key bindings for navigation in built-in accessibility support for web content. 4702 * <p> 4703 * Note: These key bindings are for the built-in accessibility navigation for 4704 * web content which is used as a fall back solution if JavaScript in a WebView 4705 * is not enabled or the user has not opted-in script injection from Google. 4706 * </p> 4707 * <p> 4708 * The bindings are separated by semi-colon. A binding is a mapping from 4709 * a key to a sequence of actions (for more details look at 4710 * android.webkit.AccessibilityInjector). A key is represented as the hexademical 4711 * string representation of an integer obtained from a meta state (optional) shifted 4712 * sixteen times left and bitwise ored with a key code. An action is represented 4713 * as a hexademical string representation of an integer where the first two digits 4714 * are navigation action index, the second, the third, and the fourth digit pairs 4715 * represent the action arguments. The separate actions in a binding are colon 4716 * separated. The key and the action sequence it maps to are separated by equals. 4717 * </p> 4718 * <p> 4719 * For example, the binding below maps the DPAD right button to traverse the 4720 * current navigation axis once without firing an accessibility event and to 4721 * perform the same traversal again but to fire an event: 4722 * <code> 4723 * 0x16=0x01000100:0x01000101; 4724 * </code> 4725 * </p> 4726 * <p> 4727 * The goal of this binding is to enable dynamic rebinding of keys to 4728 * navigation actions for web content without requiring a framework change. 4729 * </p> 4730 * <p> 4731 * This property represents a string value. 4732 * </p> 4733 * @hide 4734 */ 4735 public static final String ACCESSIBILITY_WEB_CONTENT_KEY_BINDINGS = 4736 "accessibility_web_content_key_bindings"; 4737 4738 /** 4739 * Setting that specifies whether the display magnification is enabled. 4740 * Display magnifications allows the user to zoom in the display content 4741 * and is targeted to low vision users. The current magnification scale 4742 * is controlled by {@link #ACCESSIBILITY_DISPLAY_MAGNIFICATION_SCALE}. 4743 * 4744 * @hide 4745 */ 4746 public static final String ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED = 4747 "accessibility_display_magnification_enabled"; 4748 4749 /** 4750 * Setting that specifies what the display magnification scale is. 4751 * Display magnifications allows the user to zoom in the display 4752 * content and is targeted to low vision users. Whether a display 4753 * magnification is performed is controlled by 4754 * {@link #ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED} 4755 * 4756 * @hide 4757 */ 4758 public static final String ACCESSIBILITY_DISPLAY_MAGNIFICATION_SCALE = 4759 "accessibility_display_magnification_scale"; 4760 4761 /** 4762 * Setting that specifies whether the display magnification should be 4763 * automatically updated. If this fearture is enabled the system will 4764 * exit magnification mode or pan the viewport when a context change 4765 * occurs. For example, on staring a new activity or rotating the screen, 4766 * the system may zoom out so the user can see the new context he is in. 4767 * Another example is on showing a window that is not visible in the 4768 * magnified viewport the system may pan the viewport to make the window 4769 * the has popped up so the user knows that the context has changed. 4770 * Whether a screen magnification is performed is controlled by 4771 * {@link #ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED} 4772 * 4773 * @hide 4774 */ 4775 public static final String ACCESSIBILITY_DISPLAY_MAGNIFICATION_AUTO_UPDATE = 4776 "accessibility_display_magnification_auto_update"; 4777 4778 /** 4779 * Setting that specifies whether timed text (captions) should be 4780 * displayed in video content. Text display properties are controlled by 4781 * the following settings: 4782 * <ul> 4783 * <li>{@link #ACCESSIBILITY_CAPTIONING_LOCALE} 4784 * <li>{@link #ACCESSIBILITY_CAPTIONING_BACKGROUND_COLOR} 4785 * <li>{@link #ACCESSIBILITY_CAPTIONING_FOREGROUND_COLOR} 4786 * <li>{@link #ACCESSIBILITY_CAPTIONING_EDGE_COLOR} 4787 * <li>{@link #ACCESSIBILITY_CAPTIONING_EDGE_TYPE} 4788 * <li>{@link #ACCESSIBILITY_CAPTIONING_TYPEFACE} 4789 * <li>{@link #ACCESSIBILITY_CAPTIONING_FONT_SCALE} 4790 * </ul> 4791 * 4792 * @hide 4793 */ 4794 public static final String ACCESSIBILITY_CAPTIONING_ENABLED = 4795 "accessibility_captioning_enabled"; 4796 4797 /** 4798 * Setting that specifies the language for captions as a locale string, 4799 * e.g. en_US. 4800 * 4801 * @see java.util.Locale#toString 4802 * @hide 4803 */ 4804 public static final String ACCESSIBILITY_CAPTIONING_LOCALE = 4805 "accessibility_captioning_locale"; 4806 4807 /** 4808 * Integer property that specifies the preset style for captions, one 4809 * of: 4810 * <ul> 4811 * <li>{@link android.view.accessibility.CaptioningManager.CaptionStyle#PRESET_CUSTOM} 4812 * <li>a valid index of {@link android.view.accessibility.CaptioningManager.CaptionStyle#PRESETS} 4813 * </ul> 4814 * 4815 * @see java.util.Locale#toString 4816 * @hide 4817 */ 4818 public static final String ACCESSIBILITY_CAPTIONING_PRESET = 4819 "accessibility_captioning_preset"; 4820 4821 /** 4822 * Integer property that specifes the background color for captions as a 4823 * packed 32-bit color. 4824 * 4825 * @see android.graphics.Color#argb 4826 * @hide 4827 */ 4828 public static final String ACCESSIBILITY_CAPTIONING_BACKGROUND_COLOR = 4829 "accessibility_captioning_background_color"; 4830 4831 /** 4832 * Integer property that specifes the foreground color for captions as a 4833 * packed 32-bit color. 4834 * 4835 * @see android.graphics.Color#argb 4836 * @hide 4837 */ 4838 public static final String ACCESSIBILITY_CAPTIONING_FOREGROUND_COLOR = 4839 "accessibility_captioning_foreground_color"; 4840 4841 /** 4842 * Integer property that specifes the edge type for captions, one of: 4843 * <ul> 4844 * <li>{@link android.view.accessibility.CaptioningManager.CaptionStyle#EDGE_TYPE_NONE} 4845 * <li>{@link android.view.accessibility.CaptioningManager.CaptionStyle#EDGE_TYPE_OUTLINE} 4846 * <li>{@link android.view.accessibility.CaptioningManager.CaptionStyle#EDGE_TYPE_DROP_SHADOW} 4847 * </ul> 4848 * 4849 * @see #ACCESSIBILITY_CAPTIONING_EDGE_COLOR 4850 * @hide 4851 */ 4852 public static final String ACCESSIBILITY_CAPTIONING_EDGE_TYPE = 4853 "accessibility_captioning_edge_type"; 4854 4855 /** 4856 * Integer property that specifes the edge color for captions as a 4857 * packed 32-bit color. 4858 * 4859 * @see #ACCESSIBILITY_CAPTIONING_EDGE_TYPE 4860 * @see android.graphics.Color#argb 4861 * @hide 4862 */ 4863 public static final String ACCESSIBILITY_CAPTIONING_EDGE_COLOR = 4864 "accessibility_captioning_edge_color"; 4865 4866 /** 4867 * Integer property that specifes the window color for captions as a 4868 * packed 32-bit color. 4869 * 4870 * @see android.graphics.Color#argb 4871 * @hide 4872 */ 4873 public static final String ACCESSIBILITY_CAPTIONING_WINDOW_COLOR = 4874 "accessibility_captioning_window_color"; 4875 4876 /** 4877 * String property that specifies the typeface for captions, one of: 4878 * <ul> 4879 * <li>DEFAULT 4880 * <li>MONOSPACE 4881 * <li>SANS_SERIF 4882 * <li>SERIF 4883 * </ul> 4884 * 4885 * @see android.graphics.Typeface 4886 * @hide 4887 */ 4888 public static final String ACCESSIBILITY_CAPTIONING_TYPEFACE = 4889 "accessibility_captioning_typeface"; 4890 4891 /** 4892 * Floating point property that specifies font scaling for captions. 4893 * 4894 * @hide 4895 */ 4896 public static final String ACCESSIBILITY_CAPTIONING_FONT_SCALE = 4897 "accessibility_captioning_font_scale"; 4898 4899 /** 4900 * Setting that specifies whether display color inversion is enabled. 4901 */ 4902 public static final String ACCESSIBILITY_DISPLAY_INVERSION_ENABLED = 4903 "accessibility_display_inversion_enabled"; 4904 4905 /** 4906 * Setting that specifies whether display color space adjustment is 4907 * enabled. 4908 * 4909 * @hide 4910 */ 4911 public static final String ACCESSIBILITY_DISPLAY_DALTONIZER_ENABLED = 4912 "accessibility_display_daltonizer_enabled"; 4913 4914 /** 4915 * Integer property that specifies the type of color space adjustment to 4916 * perform. Valid values are defined in AccessibilityManager. 4917 * 4918 * @hide 4919 */ 4920 public static final String ACCESSIBILITY_DISPLAY_DALTONIZER = 4921 "accessibility_display_daltonizer"; 4922 4923 /** 4924 * The timout for considering a press to be a long press in milliseconds. 4925 * @hide 4926 */ 4927 public static final String LONG_PRESS_TIMEOUT = "long_press_timeout"; 4928 4929 /** 4930 * List of the enabled print services. 4931 * @hide 4932 */ 4933 public static final String ENABLED_PRINT_SERVICES = 4934 "enabled_print_services"; 4935 4936 /** 4937 * List of the system print services we enabled on first boot. On 4938 * first boot we enable all system, i.e. bundled print services, 4939 * once, so they work out-of-the-box. 4940 * @hide 4941 */ 4942 public static final String ENABLED_ON_FIRST_BOOT_SYSTEM_PRINT_SERVICES = 4943 "enabled_on_first_boot_system_print_services"; 4944 4945 /** 4946 * Setting to always use the default text-to-speech settings regardless 4947 * of the application settings. 4948 * 1 = override application settings, 4949 * 0 = use application settings (if specified). 4950 * 4951 * @deprecated The value of this setting is no longer respected by 4952 * the framework text to speech APIs as of the Ice Cream Sandwich release. 4953 */ 4954 @Deprecated 4955 public static final String TTS_USE_DEFAULTS = "tts_use_defaults"; 4956 4957 /** 4958 * Default text-to-speech engine speech rate. 100 = 1x 4959 */ 4960 public static final String TTS_DEFAULT_RATE = "tts_default_rate"; 4961 4962 /** 4963 * Default text-to-speech engine pitch. 100 = 1x 4964 */ 4965 public static final String TTS_DEFAULT_PITCH = "tts_default_pitch"; 4966 4967 /** 4968 * Default text-to-speech engine. 4969 */ 4970 public static final String TTS_DEFAULT_SYNTH = "tts_default_synth"; 4971 4972 /** 4973 * Default text-to-speech language. 4974 * 4975 * @deprecated this setting is no longer in use, as of the Ice Cream 4976 * Sandwich release. Apps should never need to read this setting directly, 4977 * instead can query the TextToSpeech framework classes for the default 4978 * locale. {@link TextToSpeech#getLanguage()}. 4979 */ 4980 @Deprecated 4981 public static final String TTS_DEFAULT_LANG = "tts_default_lang"; 4982 4983 /** 4984 * Default text-to-speech country. 4985 * 4986 * @deprecated this setting is no longer in use, as of the Ice Cream 4987 * Sandwich release. Apps should never need to read this setting directly, 4988 * instead can query the TextToSpeech framework classes for the default 4989 * locale. {@link TextToSpeech#getLanguage()}. 4990 */ 4991 @Deprecated 4992 public static final String TTS_DEFAULT_COUNTRY = "tts_default_country"; 4993 4994 /** 4995 * Default text-to-speech locale variant. 4996 * 4997 * @deprecated this setting is no longer in use, as of the Ice Cream 4998 * Sandwich release. Apps should never need to read this setting directly, 4999 * instead can query the TextToSpeech framework classes for the 5000 * locale that is in use {@link TextToSpeech#getLanguage()}. 5001 */ 5002 @Deprecated 5003 public static final String TTS_DEFAULT_VARIANT = "tts_default_variant"; 5004 5005 /** 5006 * Stores the default tts locales on a per engine basis. Stored as 5007 * a comma seperated list of values, each value being of the form 5008 * {@code engine_name:locale} for example, 5009 * {@code com.foo.ttsengine:eng-USA,com.bar.ttsengine:esp-ESP}. This 5010 * supersedes {@link #TTS_DEFAULT_LANG}, {@link #TTS_DEFAULT_COUNTRY} and 5011 * {@link #TTS_DEFAULT_VARIANT}. Apps should never need to read this 5012 * setting directly, and can query the TextToSpeech framework classes 5013 * for the locale that is in use. 5014 * 5015 * @hide 5016 */ 5017 public static final String TTS_DEFAULT_LOCALE = "tts_default_locale"; 5018 5019 /** 5020 * Space delimited list of plugin packages that are enabled. 5021 */ 5022 public static final String TTS_ENABLED_PLUGINS = "tts_enabled_plugins"; 5023 5024 /** 5025 * @deprecated Use {@link android.provider.Settings.Global#WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON} 5026 * instead. 5027 */ 5028 @Deprecated 5029 public static final String WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON = 5030 Global.WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON; 5031 5032 /** 5033 * @deprecated Use {@link android.provider.Settings.Global#WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY} 5034 * instead. 5035 */ 5036 @Deprecated 5037 public static final String WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY = 5038 Global.WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY; 5039 5040 /** 5041 * @deprecated Use {@link android.provider.Settings.Global#WIFI_NUM_OPEN_NETWORKS_KEPT} 5042 * instead. 5043 */ 5044 @Deprecated 5045 public static final String WIFI_NUM_OPEN_NETWORKS_KEPT = 5046 Global.WIFI_NUM_OPEN_NETWORKS_KEPT; 5047 5048 /** 5049 * @deprecated Use {@link android.provider.Settings.Global#WIFI_ON} 5050 * instead. 5051 */ 5052 @Deprecated 5053 public static final String WIFI_ON = Global.WIFI_ON; 5054 5055 /** 5056 * The acceptable packet loss percentage (range 0 - 100) before trying 5057 * another AP on the same network. 5058 * @deprecated This setting is not used. 5059 */ 5060 @Deprecated 5061 public static final String WIFI_WATCHDOG_ACCEPTABLE_PACKET_LOSS_PERCENTAGE = 5062 "wifi_watchdog_acceptable_packet_loss_percentage"; 5063 5064 /** 5065 * The number of access points required for a network in order for the 5066 * watchdog to monitor it. 5067 * @deprecated This setting is not used. 5068 */ 5069 @Deprecated 5070 public static final String WIFI_WATCHDOG_AP_COUNT = "wifi_watchdog_ap_count"; 5071 5072 /** 5073 * The delay between background checks. 5074 * @deprecated This setting is not used. 5075 */ 5076 @Deprecated 5077 public static final String WIFI_WATCHDOG_BACKGROUND_CHECK_DELAY_MS = 5078 "wifi_watchdog_background_check_delay_ms"; 5079 5080 /** 5081 * Whether the Wi-Fi watchdog is enabled for background checking even 5082 * after it thinks the user has connected to a good access point. 5083 * @deprecated This setting is not used. 5084 */ 5085 @Deprecated 5086 public static final String WIFI_WATCHDOG_BACKGROUND_CHECK_ENABLED = 5087 "wifi_watchdog_background_check_enabled"; 5088 5089 /** 5090 * The timeout for a background ping 5091 * @deprecated This setting is not used. 5092 */ 5093 @Deprecated 5094 public static final String WIFI_WATCHDOG_BACKGROUND_CHECK_TIMEOUT_MS = 5095 "wifi_watchdog_background_check_timeout_ms"; 5096 5097 /** 5098 * The number of initial pings to perform that *may* be ignored if they 5099 * fail. Again, if these fail, they will *not* be used in packet loss 5100 * calculation. For example, one network always seemed to time out for 5101 * the first couple pings, so this is set to 3 by default. 5102 * @deprecated This setting is not used. 5103 */ 5104 @Deprecated 5105 public static final String WIFI_WATCHDOG_INITIAL_IGNORED_PING_COUNT = 5106 "wifi_watchdog_initial_ignored_ping_count"; 5107 5108 /** 5109 * The maximum number of access points (per network) to attempt to test. 5110 * If this number is reached, the watchdog will no longer monitor the 5111 * initial connection state for the network. This is a safeguard for 5112 * networks containing multiple APs whose DNS does not respond to pings. 5113 * @deprecated This setting is not used. 5114 */ 5115 @Deprecated 5116 public static final String WIFI_WATCHDOG_MAX_AP_CHECKS = "wifi_watchdog_max_ap_checks"; 5117 5118 /** 5119 * @deprecated Use {@link android.provider.Settings.Global#WIFI_WATCHDOG_ON} instead 5120 */ 5121 @Deprecated 5122 public static final String WIFI_WATCHDOG_ON = "wifi_watchdog_on"; 5123 5124 /** 5125 * A comma-separated list of SSIDs for which the Wi-Fi watchdog should be enabled. 5126 * @deprecated This setting is not used. 5127 */ 5128 @Deprecated 5129 public static final String WIFI_WATCHDOG_WATCH_LIST = "wifi_watchdog_watch_list"; 5130 5131 /** 5132 * The number of pings to test if an access point is a good connection. 5133 * @deprecated This setting is not used. 5134 */ 5135 @Deprecated 5136 public static final String WIFI_WATCHDOG_PING_COUNT = "wifi_watchdog_ping_count"; 5137 5138 /** 5139 * The delay between pings. 5140 * @deprecated This setting is not used. 5141 */ 5142 @Deprecated 5143 public static final String WIFI_WATCHDOG_PING_DELAY_MS = "wifi_watchdog_ping_delay_ms"; 5144 5145 /** 5146 * The timeout per ping. 5147 * @deprecated This setting is not used. 5148 */ 5149 @Deprecated 5150 public static final String WIFI_WATCHDOG_PING_TIMEOUT_MS = "wifi_watchdog_ping_timeout_ms"; 5151 5152 /** 5153 * @deprecated Use 5154 * {@link android.provider.Settings.Global#WIFI_MAX_DHCP_RETRY_COUNT} instead 5155 */ 5156 @Deprecated 5157 public static final String WIFI_MAX_DHCP_RETRY_COUNT = Global.WIFI_MAX_DHCP_RETRY_COUNT; 5158 5159 /** 5160 * @deprecated Use 5161 * {@link android.provider.Settings.Global#WIFI_MOBILE_DATA_TRANSITION_WAKELOCK_TIMEOUT_MS} instead 5162 */ 5163 @Deprecated 5164 public static final String WIFI_MOBILE_DATA_TRANSITION_WAKELOCK_TIMEOUT_MS = 5165 Global.WIFI_MOBILE_DATA_TRANSITION_WAKELOCK_TIMEOUT_MS; 5166 5167 /** 5168 * The number of milliseconds to hold on to a PendingIntent based request. This delay gives 5169 * the receivers of the PendingIntent an opportunity to make a new network request before 5170 * the Network satisfying the request is potentially removed. 5171 * 5172 * @hide 5173 */ 5174 public static final String CONNECTIVITY_RELEASE_PENDING_INTENT_DELAY_MS = 5175 "connectivity_release_pending_intent_delay_ms"; 5176 5177 /** 5178 * Whether background data usage is allowed. 5179 * 5180 * @deprecated As of {@link VERSION_CODES#ICE_CREAM_SANDWICH}, 5181 * availability of background data depends on several 5182 * combined factors. When background data is unavailable, 5183 * {@link ConnectivityManager#getActiveNetworkInfo()} will 5184 * now appear disconnected. 5185 */ 5186 @Deprecated 5187 public static final String BACKGROUND_DATA = "background_data"; 5188 5189 /** 5190 * Origins for which browsers should allow geolocation by default. 5191 * The value is a space-separated list of origins. 5192 */ 5193 public static final String ALLOWED_GEOLOCATION_ORIGINS 5194 = "allowed_geolocation_origins"; 5195 5196 /** 5197 * The preferred TTY mode 0 = TTy Off, CDMA default 5198 * 1 = TTY Full 5199 * 2 = TTY HCO 5200 * 3 = TTY VCO 5201 * @hide 5202 */ 5203 public static final String PREFERRED_TTY_MODE = 5204 "preferred_tty_mode"; 5205 5206 /** 5207 * Whether the enhanced voice privacy mode is enabled. 5208 * 0 = normal voice privacy 5209 * 1 = enhanced voice privacy 5210 * @hide 5211 */ 5212 public static final String ENHANCED_VOICE_PRIVACY_ENABLED = "enhanced_voice_privacy_enabled"; 5213 5214 /** 5215 * Whether the TTY mode mode is enabled. 5216 * 0 = disabled 5217 * 1 = enabled 5218 * @hide 5219 */ 5220 public static final String TTY_MODE_ENABLED = "tty_mode_enabled"; 5221 5222 /** 5223 * Controls whether settings backup is enabled. 5224 * Type: int ( 0 = disabled, 1 = enabled ) 5225 * @hide 5226 */ 5227 public static final String BACKUP_ENABLED = "backup_enabled"; 5228 5229 /** 5230 * Controls whether application data is automatically restored from backup 5231 * at install time. 5232 * Type: int ( 0 = disabled, 1 = enabled ) 5233 * @hide 5234 */ 5235 public static final String BACKUP_AUTO_RESTORE = "backup_auto_restore"; 5236 5237 /** 5238 * Indicates whether settings backup has been fully provisioned. 5239 * Type: int ( 0 = unprovisioned, 1 = fully provisioned ) 5240 * @hide 5241 */ 5242 public static final String BACKUP_PROVISIONED = "backup_provisioned"; 5243 5244 /** 5245 * Component of the transport to use for backup/restore. 5246 * @hide 5247 */ 5248 public static final String BACKUP_TRANSPORT = "backup_transport"; 5249 5250 /** 5251 * Version for which the setup wizard was last shown. Bumped for 5252 * each release when there is new setup information to show. 5253 * @hide 5254 */ 5255 public static final String LAST_SETUP_SHOWN = "last_setup_shown"; 5256 5257 /** 5258 * The interval in milliseconds after which Wi-Fi is considered idle. 5259 * When idle, it is possible for the device to be switched from Wi-Fi to 5260 * the mobile data network. 5261 * @hide 5262 * @deprecated Use {@link android.provider.Settings.Global#WIFI_IDLE_MS} 5263 * instead. 5264 */ 5265 @Deprecated 5266 public static final String WIFI_IDLE_MS = Global.WIFI_IDLE_MS; 5267 5268 /** 5269 * The global search provider chosen by the user (if multiple global 5270 * search providers are installed). This will be the provider returned 5271 * by {@link SearchManager#getGlobalSearchActivity()} if it's still 5272 * installed. This setting is stored as a flattened component name as 5273 * per {@link ComponentName#flattenToString()}. 5274 * 5275 * @hide 5276 */ 5277 public static final String SEARCH_GLOBAL_SEARCH_ACTIVITY = 5278 "search_global_search_activity"; 5279 5280 /** 5281 * The number of promoted sources in GlobalSearch. 5282 * @hide 5283 */ 5284 public static final String SEARCH_NUM_PROMOTED_SOURCES = "search_num_promoted_sources"; 5285 /** 5286 * The maximum number of suggestions returned by GlobalSearch. 5287 * @hide 5288 */ 5289 public static final String SEARCH_MAX_RESULTS_TO_DISPLAY = "search_max_results_to_display"; 5290 /** 5291 * The number of suggestions GlobalSearch will ask each non-web search source for. 5292 * @hide 5293 */ 5294 public static final String SEARCH_MAX_RESULTS_PER_SOURCE = "search_max_results_per_source"; 5295 /** 5296 * The number of suggestions the GlobalSearch will ask the web search source for. 5297 * @hide 5298 */ 5299 public static final String SEARCH_WEB_RESULTS_OVERRIDE_LIMIT = 5300 "search_web_results_override_limit"; 5301 /** 5302 * The number of milliseconds that GlobalSearch will wait for suggestions from 5303 * promoted sources before continuing with all other sources. 5304 * @hide 5305 */ 5306 public static final String SEARCH_PROMOTED_SOURCE_DEADLINE_MILLIS = 5307 "search_promoted_source_deadline_millis"; 5308 /** 5309 * The number of milliseconds before GlobalSearch aborts search suggesiton queries. 5310 * @hide 5311 */ 5312 public static final String SEARCH_SOURCE_TIMEOUT_MILLIS = "search_source_timeout_millis"; 5313 /** 5314 * The maximum number of milliseconds that GlobalSearch shows the previous results 5315 * after receiving a new query. 5316 * @hide 5317 */ 5318 public static final String SEARCH_PREFILL_MILLIS = "search_prefill_millis"; 5319 /** 5320 * The maximum age of log data used for shortcuts in GlobalSearch. 5321 * @hide 5322 */ 5323 public static final String SEARCH_MAX_STAT_AGE_MILLIS = "search_max_stat_age_millis"; 5324 /** 5325 * The maximum age of log data used for source ranking in GlobalSearch. 5326 * @hide 5327 */ 5328 public static final String SEARCH_MAX_SOURCE_EVENT_AGE_MILLIS = 5329 "search_max_source_event_age_millis"; 5330 /** 5331 * The minimum number of impressions needed to rank a source in GlobalSearch. 5332 * @hide 5333 */ 5334 public static final String SEARCH_MIN_IMPRESSIONS_FOR_SOURCE_RANKING = 5335 "search_min_impressions_for_source_ranking"; 5336 /** 5337 * The minimum number of clicks needed to rank a source in GlobalSearch. 5338 * @hide 5339 */ 5340 public static final String SEARCH_MIN_CLICKS_FOR_SOURCE_RANKING = 5341 "search_min_clicks_for_source_ranking"; 5342 /** 5343 * The maximum number of shortcuts shown by GlobalSearch. 5344 * @hide 5345 */ 5346 public static final String SEARCH_MAX_SHORTCUTS_RETURNED = "search_max_shortcuts_returned"; 5347 /** 5348 * The size of the core thread pool for suggestion queries in GlobalSearch. 5349 * @hide 5350 */ 5351 public static final String SEARCH_QUERY_THREAD_CORE_POOL_SIZE = 5352 "search_query_thread_core_pool_size"; 5353 /** 5354 * The maximum size of the thread pool for suggestion queries in GlobalSearch. 5355 * @hide 5356 */ 5357 public static final String SEARCH_QUERY_THREAD_MAX_POOL_SIZE = 5358 "search_query_thread_max_pool_size"; 5359 /** 5360 * The size of the core thread pool for shortcut refreshing in GlobalSearch. 5361 * @hide 5362 */ 5363 public static final String SEARCH_SHORTCUT_REFRESH_CORE_POOL_SIZE = 5364 "search_shortcut_refresh_core_pool_size"; 5365 /** 5366 * The maximum size of the thread pool for shortcut refreshing in GlobalSearch. 5367 * @hide 5368 */ 5369 public static final String SEARCH_SHORTCUT_REFRESH_MAX_POOL_SIZE = 5370 "search_shortcut_refresh_max_pool_size"; 5371 /** 5372 * The maximun time that excess threads in the GlobalSeach thread pools will 5373 * wait before terminating. 5374 * @hide 5375 */ 5376 public static final String SEARCH_THREAD_KEEPALIVE_SECONDS = 5377 "search_thread_keepalive_seconds"; 5378 /** 5379 * The maximum number of concurrent suggestion queries to each source. 5380 * @hide 5381 */ 5382 public static final String SEARCH_PER_SOURCE_CONCURRENT_QUERY_LIMIT = 5383 "search_per_source_concurrent_query_limit"; 5384 5385 /** 5386 * Whether or not alert sounds are played on MountService events. (0 = false, 1 = true) 5387 * @hide 5388 */ 5389 public static final String MOUNT_PLAY_NOTIFICATION_SND = "mount_play_not_snd"; 5390 5391 /** 5392 * Whether or not UMS auto-starts on UMS host detection. (0 = false, 1 = true) 5393 * @hide 5394 */ 5395 public static final String MOUNT_UMS_AUTOSTART = "mount_ums_autostart"; 5396 5397 /** 5398 * Whether or not a notification is displayed on UMS host detection. (0 = false, 1 = true) 5399 * @hide 5400 */ 5401 public static final String MOUNT_UMS_PROMPT = "mount_ums_prompt"; 5402 5403 /** 5404 * Whether or not a notification is displayed while UMS is enabled. (0 = false, 1 = true) 5405 * @hide 5406 */ 5407 public static final String MOUNT_UMS_NOTIFY_ENABLED = "mount_ums_notify_enabled"; 5408 5409 /** 5410 * If nonzero, ANRs in invisible background processes bring up a dialog. 5411 * Otherwise, the process will be silently killed. 5412 * @hide 5413 */ 5414 public static final String ANR_SHOW_BACKGROUND = "anr_show_background"; 5415 5416 /** 5417 * The {@link ComponentName} string of the service to be used as the voice recognition 5418 * service. 5419 * 5420 * @hide 5421 */ 5422 public static final String VOICE_RECOGNITION_SERVICE = "voice_recognition_service"; 5423 5424 /** 5425 * Stores whether an user has consented to have apps verified through PAM. 5426 * The value is boolean (1 or 0). 5427 * 5428 * @hide 5429 */ 5430 public static final String PACKAGE_VERIFIER_USER_CONSENT = 5431 "package_verifier_user_consent"; 5432 5433 /** 5434 * The {@link ComponentName} string of the selected spell checker service which is 5435 * one of the services managed by the text service manager. 5436 * 5437 * @hide 5438 */ 5439 public static final String SELECTED_SPELL_CHECKER = "selected_spell_checker"; 5440 5441 /** 5442 * The {@link ComponentName} string of the selected subtype of the selected spell checker 5443 * service which is one of the services managed by the text service manager. 5444 * 5445 * @hide 5446 */ 5447 public static final String SELECTED_SPELL_CHECKER_SUBTYPE = 5448 "selected_spell_checker_subtype"; 5449 5450 /** 5451 * The {@link ComponentName} string whether spell checker is enabled or not. 5452 * 5453 * @hide 5454 */ 5455 public static final String SPELL_CHECKER_ENABLED = "spell_checker_enabled"; 5456 5457 /** 5458 * What happens when the user presses the Power button while in-call 5459 * and the screen is on.<br/> 5460 * <b>Values:</b><br/> 5461 * 1 - The Power button turns off the screen and locks the device. (Default behavior)<br/> 5462 * 2 - The Power button hangs up the current call.<br/> 5463 * 5464 * @hide 5465 */ 5466 public static final String INCALL_POWER_BUTTON_BEHAVIOR = "incall_power_button_behavior"; 5467 5468 /** 5469 * INCALL_POWER_BUTTON_BEHAVIOR value for "turn off screen". 5470 * @hide 5471 */ 5472 public static final int INCALL_POWER_BUTTON_BEHAVIOR_SCREEN_OFF = 0x1; 5473 5474 /** 5475 * INCALL_POWER_BUTTON_BEHAVIOR value for "hang up". 5476 * @hide 5477 */ 5478 public static final int INCALL_POWER_BUTTON_BEHAVIOR_HANGUP = 0x2; 5479 5480 /** 5481 * INCALL_POWER_BUTTON_BEHAVIOR default value. 5482 * @hide 5483 */ 5484 public static final int INCALL_POWER_BUTTON_BEHAVIOR_DEFAULT = 5485 INCALL_POWER_BUTTON_BEHAVIOR_SCREEN_OFF; 5486 5487 /** 5488 * Whether the device should wake when the wake gesture sensor detects motion. 5489 * @hide 5490 */ 5491 public static final String WAKE_GESTURE_ENABLED = "wake_gesture_enabled"; 5492 5493 /** 5494 * Whether the device should doze if configured. 5495 * @hide 5496 */ 5497 public static final String DOZE_ENABLED = "doze_enabled"; 5498 5499 /** 5500 * The current night mode that has been selected by the user. Owned 5501 * and controlled by UiModeManagerService. Constants are as per 5502 * UiModeManager. 5503 * @hide 5504 */ 5505 public static final String UI_NIGHT_MODE = "ui_night_mode"; 5506 5507 /** 5508 * Whether screensavers are enabled. 5509 * @hide 5510 */ 5511 public static final String SCREENSAVER_ENABLED = "screensaver_enabled"; 5512 5513 /** 5514 * The user's chosen screensaver components. 5515 * 5516 * These will be launched by the PhoneWindowManager after a timeout when not on 5517 * battery, or upon dock insertion (if SCREENSAVER_ACTIVATE_ON_DOCK is set to 1). 5518 * @hide 5519 */ 5520 public static final String SCREENSAVER_COMPONENTS = "screensaver_components"; 5521 5522 /** 5523 * If screensavers are enabled, whether the screensaver should be automatically launched 5524 * when the device is inserted into a (desk) dock. 5525 * @hide 5526 */ 5527 public static final String SCREENSAVER_ACTIVATE_ON_DOCK = "screensaver_activate_on_dock"; 5528 5529 /** 5530 * If screensavers are enabled, whether the screensaver should be automatically launched 5531 * when the screen times out when not on battery. 5532 * @hide 5533 */ 5534 public static final String SCREENSAVER_ACTIVATE_ON_SLEEP = "screensaver_activate_on_sleep"; 5535 5536 /** 5537 * If screensavers are enabled, the default screensaver component. 5538 * @hide 5539 */ 5540 public static final String SCREENSAVER_DEFAULT_COMPONENT = "screensaver_default_component"; 5541 5542 /** 5543 * The default NFC payment component 5544 * @hide 5545 */ 5546 public static final String NFC_PAYMENT_DEFAULT_COMPONENT = "nfc_payment_default_component"; 5547 5548 /** 5549 * Whether NFC payment is handled by the foreground application or a default. 5550 * @hide 5551 */ 5552 public static final String NFC_PAYMENT_FOREGROUND = "nfc_payment_foreground"; 5553 5554 /** 5555 * Specifies the package name currently configured to be the primary sms application 5556 * @hide 5557 */ 5558 public static final String SMS_DEFAULT_APPLICATION = "sms_default_application"; 5559 5560 /** 5561 * Specifies the package name currently configured to be the default dialer application 5562 * @hide 5563 */ 5564 public static final String DIALER_DEFAULT_APPLICATION = "dialer_default_application"; 5565 5566 /** 5567 * Specifies the package name currently configured to be the emergency assistance application 5568 * 5569 * @see android.telephony.TelephonyManager#ACTION_EMERGENCY_ASSISTANCE 5570 * 5571 * @hide 5572 */ 5573 public static final String EMERGENCY_ASSISTANCE_APPLICATION = "emergency_assistance_application"; 5574 5575 /** 5576 * Specifies whether the current app context on scren (assist data) will be sent to the 5577 * assist application (active voice interaction service). 5578 * 5579 * @hide 5580 */ 5581 public static final String ASSIST_STRUCTURE_ENABLED = "assist_structure_enabled"; 5582 5583 /** 5584 * Specifies whether a screenshot of the screen contents will be sent to the assist 5585 * application (active voice interaction service). 5586 * 5587 * @hide 5588 */ 5589 public static final String ASSIST_SCREENSHOT_ENABLED = "assist_screenshot_enabled"; 5590 5591 /** 5592 * Names of the service components that the current user has explicitly allowed to 5593 * see all of the user's notifications, separated by ':'. 5594 * 5595 * @hide 5596 */ 5597 public static final String ENABLED_NOTIFICATION_LISTENERS = "enabled_notification_listeners"; 5598 5599 /** 5600 * Names of the packages that the current user has explicitly allowed to 5601 * manage notification policy configuration, separated by ':'. 5602 * 5603 * @hide 5604 */ 5605 public static final String ENABLED_NOTIFICATION_POLICY_ACCESS_PACKAGES = 5606 "enabled_notification_policy_access_packages"; 5607 5608 /** 5609 * @hide 5610 */ 5611 public static final String ENABLED_CONDITION_PROVIDERS = "enabled_condition_providers"; 5612 5613 /** @hide */ 5614 public static final String BAR_SERVICE_COMPONENT = "bar_service_component"; 5615 5616 /** @hide */ 5617 public static final String VOLUME_CONTROLLER_SERVICE_COMPONENT 5618 = "volume_controller_service_component"; 5619 5620 /** @hide */ 5621 public static final String IMMERSIVE_MODE_CONFIRMATIONS = "immersive_mode_confirmations"; 5622 5623 /** 5624 * This is the query URI for finding a print service to install. 5625 * 5626 * @hide 5627 */ 5628 public static final String PRINT_SERVICE_SEARCH_URI = "print_service_search_uri"; 5629 5630 /** 5631 * This is the query URI for finding a NFC payment service to install. 5632 * 5633 * @hide 5634 */ 5635 public static final String PAYMENT_SERVICE_SEARCH_URI = "payment_service_search_uri"; 5636 5637 /** 5638 * If enabled, apps should try to skip any introductory hints on first launch. This might 5639 * apply to users that are already familiar with the environment or temporary users. 5640 * <p> 5641 * Type : int (0 to show hints, 1 to skip showing hints) 5642 */ 5643 public static final String SKIP_FIRST_USE_HINTS = "skip_first_use_hints"; 5644 5645 /** 5646 * Persisted playback time after a user confirmation of an unsafe volume level. 5647 * 5648 * @hide 5649 */ 5650 public static final String UNSAFE_VOLUME_MUSIC_ACTIVE_MS = "unsafe_volume_music_active_ms"; 5651 5652 /** 5653 * This preference enables notification display on the lockscreen. 5654 * @hide 5655 */ 5656 public static final String LOCK_SCREEN_SHOW_NOTIFICATIONS = 5657 "lock_screen_show_notifications"; 5658 5659 /** 5660 * List of TV inputs that are currently hidden. This is a string 5661 * containing the IDs of all hidden TV inputs. Each ID is encoded by 5662 * {@link android.net.Uri#encode(String)} and separated by ':'. 5663 * @hide 5664 */ 5665 public static final String TV_INPUT_HIDDEN_INPUTS = "tv_input_hidden_inputs"; 5666 5667 /** 5668 * List of custom TV input labels. This is a string containing <TV input id, custom name> 5669 * pairs. TV input id and custom name are encoded by {@link android.net.Uri#encode(String)} 5670 * and separated by ','. Each pair is separated by ':'. 5671 * @hide 5672 */ 5673 public static final String TV_INPUT_CUSTOM_LABELS = "tv_input_custom_labels"; 5674 5675 /** 5676 * Whether automatic routing of system audio to USB audio peripheral is disabled. 5677 * The value is boolean (1 or 0), where 1 means automatic routing is disabled, 5678 * and 0 means automatic routing is enabled. 5679 * 5680 * @hide 5681 */ 5682 public static final String USB_AUDIO_AUTOMATIC_ROUTING_DISABLED = 5683 "usb_audio_automatic_routing_disabled"; 5684 5685 /** 5686 * The timeout in milliseconds before the device fully goes to sleep after 5687 * a period of inactivity. This value sets an upper bound on how long the device 5688 * will stay awake or dreaming without user activity. It should generally 5689 * be longer than {@link Settings.System#SCREEN_OFF_TIMEOUT} as otherwise the device 5690 * will sleep before it ever has a chance to dream. 5691 * <p> 5692 * Use -1 to disable this timeout. 5693 * </p> 5694 * 5695 * @hide 5696 */ 5697 public static final String SLEEP_TIMEOUT = "sleep_timeout"; 5698 5699 /** 5700 * Controls whether double tap to wake is enabled. 5701 * @hide 5702 */ 5703 public static final String DOUBLE_TAP_TO_WAKE = "double_tap_to_wake"; 5704 5705 /** 5706 * The current assistant component. It could be a voice interaction service, 5707 * or an activity that handles ACTION_ASSIST, or empty which means using the default 5708 * handling. 5709 * 5710 * @hide 5711 */ 5712 public static final String ASSISTANT = "assistant"; 5713 5714 /** 5715 * This are the settings to be backed up. 5716 * 5717 * NOTE: Settings are backed up and restored in the order they appear 5718 * in this array. If you have one setting depending on another, 5719 * make sure that they are ordered appropriately. 5720 * 5721 * @hide 5722 */ 5723 public static final String[] SETTINGS_TO_BACKUP = { 5724 BUGREPORT_IN_POWER_MENU, // moved to global 5725 ALLOW_MOCK_LOCATION, 5726 PARENTAL_CONTROL_ENABLED, 5727 PARENTAL_CONTROL_REDIRECT_URL, 5728 USB_MASS_STORAGE_ENABLED, // moved to global 5729 ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED, 5730 ACCESSIBILITY_DISPLAY_MAGNIFICATION_SCALE, 5731 ACCESSIBILITY_DISPLAY_MAGNIFICATION_AUTO_UPDATE, 5732 ACCESSIBILITY_SCRIPT_INJECTION, 5733 BACKUP_AUTO_RESTORE, 5734 ENABLED_ACCESSIBILITY_SERVICES, 5735 ENABLED_NOTIFICATION_LISTENERS, 5736 ENABLED_INPUT_METHODS, 5737 TOUCH_EXPLORATION_GRANTED_ACCESSIBILITY_SERVICES, 5738 TOUCH_EXPLORATION_ENABLED, 5739 ACCESSIBILITY_ENABLED, 5740 ACCESSIBILITY_SPEAK_PASSWORD, 5741 ACCESSIBILITY_HIGH_TEXT_CONTRAST_ENABLED, 5742 ACCESSIBILITY_CAPTIONING_ENABLED, 5743 ACCESSIBILITY_CAPTIONING_LOCALE, 5744 ACCESSIBILITY_CAPTIONING_BACKGROUND_COLOR, 5745 ACCESSIBILITY_CAPTIONING_FOREGROUND_COLOR, 5746 ACCESSIBILITY_CAPTIONING_EDGE_TYPE, 5747 ACCESSIBILITY_CAPTIONING_EDGE_COLOR, 5748 ACCESSIBILITY_CAPTIONING_TYPEFACE, 5749 ACCESSIBILITY_CAPTIONING_FONT_SCALE, 5750 TTS_USE_DEFAULTS, 5751 TTS_DEFAULT_RATE, 5752 TTS_DEFAULT_PITCH, 5753 TTS_DEFAULT_SYNTH, 5754 TTS_DEFAULT_LANG, 5755 TTS_DEFAULT_COUNTRY, 5756 TTS_ENABLED_PLUGINS, 5757 TTS_DEFAULT_LOCALE, 5758 WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON, // moved to global 5759 WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY, // moved to global 5760 WIFI_NUM_OPEN_NETWORKS_KEPT, // moved to global 5761 SELECTED_SPELL_CHECKER, 5762 SELECTED_SPELL_CHECKER_SUBTYPE, 5763 SPELL_CHECKER_ENABLED, 5764 MOUNT_PLAY_NOTIFICATION_SND, 5765 MOUNT_UMS_AUTOSTART, 5766 MOUNT_UMS_PROMPT, 5767 MOUNT_UMS_NOTIFY_ENABLED, 5768 SLEEP_TIMEOUT, 5769 DOUBLE_TAP_TO_WAKE, 5770 }; 5771 5772 /** 5773 * These entries are considered common between the personal and the managed profile, 5774 * since the managed profile doesn't get to change them. 5775 */ 5776 private static final Set<String> CLONE_TO_MANAGED_PROFILE = new ArraySet<>(); 5777 5778 static { 5779 CLONE_TO_MANAGED_PROFILE.add(ACCESSIBILITY_ENABLED); 5780 CLONE_TO_MANAGED_PROFILE.add(ALLOW_MOCK_LOCATION); 5781 CLONE_TO_MANAGED_PROFILE.add(ALLOWED_GEOLOCATION_ORIGINS); 5782 CLONE_TO_MANAGED_PROFILE.add(DEFAULT_INPUT_METHOD); 5783 CLONE_TO_MANAGED_PROFILE.add(ENABLED_ACCESSIBILITY_SERVICES); 5784 CLONE_TO_MANAGED_PROFILE.add(ENABLED_INPUT_METHODS); 5785 CLONE_TO_MANAGED_PROFILE.add(LOCATION_MODE); 5786 CLONE_TO_MANAGED_PROFILE.add(LOCATION_PROVIDERS_ALLOWED); 5787 CLONE_TO_MANAGED_PROFILE.add(LOCK_SCREEN_ALLOW_PRIVATE_NOTIFICATIONS); 5788 CLONE_TO_MANAGED_PROFILE.add(SELECTED_INPUT_METHOD_SUBTYPE); 5789 CLONE_TO_MANAGED_PROFILE.add(SELECTED_SPELL_CHECKER); 5790 CLONE_TO_MANAGED_PROFILE.add(SELECTED_SPELL_CHECKER_SUBTYPE); 5791 } 5792 5793 /** @hide */ getCloneToManagedProfileSettings(Set<String> outKeySet)5794 public static void getCloneToManagedProfileSettings(Set<String> outKeySet) { 5795 outKeySet.addAll(CLONE_TO_MANAGED_PROFILE); 5796 } 5797 5798 /** 5799 * Helper method for determining if a location provider is enabled. 5800 * 5801 * @param cr the content resolver to use 5802 * @param provider the location provider to query 5803 * @return true if the provider is enabled 5804 * 5805 * @deprecated use {@link #LOCATION_MODE} or 5806 * {@link LocationManager#isProviderEnabled(String)} 5807 */ 5808 @Deprecated isLocationProviderEnabled(ContentResolver cr, String provider)5809 public static final boolean isLocationProviderEnabled(ContentResolver cr, String provider) { 5810 return isLocationProviderEnabledForUser(cr, provider, UserHandle.myUserId()); 5811 } 5812 5813 /** 5814 * Helper method for determining if a location provider is enabled. 5815 * @param cr the content resolver to use 5816 * @param provider the location provider to query 5817 * @param userId the userId to query 5818 * @return true if the provider is enabled 5819 * @deprecated use {@link #LOCATION_MODE} or 5820 * {@link LocationManager#isProviderEnabled(String)} 5821 * @hide 5822 */ 5823 @Deprecated isLocationProviderEnabledForUser(ContentResolver cr, String provider, int userId)5824 public static final boolean isLocationProviderEnabledForUser(ContentResolver cr, String provider, int userId) { 5825 String allowedProviders = Settings.Secure.getStringForUser(cr, 5826 LOCATION_PROVIDERS_ALLOWED, userId); 5827 return TextUtils.delimitedStringContains(allowedProviders, ',', provider); 5828 } 5829 5830 /** 5831 * Thread-safe method for enabling or disabling a single location provider. 5832 * @param cr the content resolver to use 5833 * @param provider the location provider to enable or disable 5834 * @param enabled true if the provider should be enabled 5835 * @deprecated use {@link #putInt(ContentResolver, String, int)} and {@link #LOCATION_MODE} 5836 */ 5837 @Deprecated setLocationProviderEnabled(ContentResolver cr, String provider, boolean enabled)5838 public static final void setLocationProviderEnabled(ContentResolver cr, 5839 String provider, boolean enabled) { 5840 setLocationProviderEnabledForUser(cr, provider, enabled, UserHandle.myUserId()); 5841 } 5842 5843 /** 5844 * Thread-safe method for enabling or disabling a single location provider. 5845 * 5846 * @param cr the content resolver to use 5847 * @param provider the location provider to enable or disable 5848 * @param enabled true if the provider should be enabled 5849 * @param userId the userId for which to enable/disable providers 5850 * @return true if the value was set, false on database errors 5851 * @deprecated use {@link #putIntForUser(ContentResolver, String, int, int)} and 5852 * {@link #LOCATION_MODE} 5853 * @hide 5854 */ 5855 @Deprecated setLocationProviderEnabledForUser(ContentResolver cr, String provider, boolean enabled, int userId)5856 public static final boolean setLocationProviderEnabledForUser(ContentResolver cr, 5857 String provider, boolean enabled, int userId) { 5858 synchronized (mLocationSettingsLock) { 5859 // to ensure thread safety, we write the provider name with a '+' or '-' 5860 // and let the SettingsProvider handle it rather than reading and modifying 5861 // the list of enabled providers. 5862 if (enabled) { 5863 provider = "+" + provider; 5864 } else { 5865 provider = "-" + provider; 5866 } 5867 return putStringForUser(cr, Settings.Secure.LOCATION_PROVIDERS_ALLOWED, provider, 5868 userId); 5869 } 5870 } 5871 5872 /** 5873 * Thread-safe method for setting the location mode to one of 5874 * {@link #LOCATION_MODE_HIGH_ACCURACY}, {@link #LOCATION_MODE_SENSORS_ONLY}, 5875 * {@link #LOCATION_MODE_BATTERY_SAVING}, or {@link #LOCATION_MODE_OFF}. 5876 * 5877 * @param cr the content resolver to use 5878 * @param mode such as {@link #LOCATION_MODE_HIGH_ACCURACY} 5879 * @param userId the userId for which to change mode 5880 * @return true if the value was set, false on database errors 5881 * 5882 * @throws IllegalArgumentException if mode is not one of the supported values 5883 */ setLocationModeForUser(ContentResolver cr, int mode, int userId)5884 private static final boolean setLocationModeForUser(ContentResolver cr, int mode, 5885 int userId) { 5886 synchronized (mLocationSettingsLock) { 5887 boolean gps = false; 5888 boolean network = false; 5889 switch (mode) { 5890 case LOCATION_MODE_OFF: 5891 break; 5892 case LOCATION_MODE_SENSORS_ONLY: 5893 gps = true; 5894 break; 5895 case LOCATION_MODE_BATTERY_SAVING: 5896 network = true; 5897 break; 5898 case LOCATION_MODE_HIGH_ACCURACY: 5899 gps = true; 5900 network = true; 5901 break; 5902 default: 5903 throw new IllegalArgumentException("Invalid location mode: " + mode); 5904 } 5905 // Note it's important that we set the NLP mode first. The Google implementation 5906 // of NLP clears its NLP consent setting any time it receives a 5907 // LocationManager.PROVIDERS_CHANGED_ACTION broadcast and NLP is disabled. Also, 5908 // it shows an NLP consent dialog any time it receives the broadcast, NLP is 5909 // enabled, and the NLP consent is not set. If 1) we were to enable GPS first, 5910 // 2) a setup wizard has its own NLP consent UI that sets the NLP consent setting, 5911 // and 3) the receiver happened to complete before we enabled NLP, then the Google 5912 // NLP would detect the attempt to enable NLP and show a redundant NLP consent 5913 // dialog. Then the people who wrote the setup wizard would be sad. 5914 boolean nlpSuccess = Settings.Secure.setLocationProviderEnabledForUser( 5915 cr, LocationManager.NETWORK_PROVIDER, network, userId); 5916 boolean gpsSuccess = Settings.Secure.setLocationProviderEnabledForUser( 5917 cr, LocationManager.GPS_PROVIDER, gps, userId); 5918 return gpsSuccess && nlpSuccess; 5919 } 5920 } 5921 5922 /** 5923 * Thread-safe method for reading the location mode, returns one of 5924 * {@link #LOCATION_MODE_HIGH_ACCURACY}, {@link #LOCATION_MODE_SENSORS_ONLY}, 5925 * {@link #LOCATION_MODE_BATTERY_SAVING}, or {@link #LOCATION_MODE_OFF}. 5926 * 5927 * @param cr the content resolver to use 5928 * @param userId the userId for which to read the mode 5929 * @return the location mode 5930 */ getLocationModeForUser(ContentResolver cr, int userId)5931 private static final int getLocationModeForUser(ContentResolver cr, int userId) { 5932 synchronized (mLocationSettingsLock) { 5933 boolean gpsEnabled = Settings.Secure.isLocationProviderEnabledForUser( 5934 cr, LocationManager.GPS_PROVIDER, userId); 5935 boolean networkEnabled = Settings.Secure.isLocationProviderEnabledForUser( 5936 cr, LocationManager.NETWORK_PROVIDER, userId); 5937 if (gpsEnabled && networkEnabled) { 5938 return LOCATION_MODE_HIGH_ACCURACY; 5939 } else if (gpsEnabled) { 5940 return LOCATION_MODE_SENSORS_ONLY; 5941 } else if (networkEnabled) { 5942 return LOCATION_MODE_BATTERY_SAVING; 5943 } else { 5944 return LOCATION_MODE_OFF; 5945 } 5946 } 5947 } 5948 } 5949 5950 /** 5951 * Global system settings, containing preferences that always apply identically 5952 * to all defined users. Applications can read these but are not allowed to write; 5953 * like the "Secure" settings, these are for preferences that the user must 5954 * explicitly modify through the system UI or specialized APIs for those values. 5955 */ 5956 public static final class Global extends NameValueTable { 5957 public static final String SYS_PROP_SETTING_VERSION = "sys.settings_global_version"; 5958 5959 /** 5960 * The content:// style URL for global secure settings items. Not public. 5961 */ 5962 public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/global"); 5963 5964 /** 5965 * Whether users are allowed to add more users or guest from lockscreen. 5966 * <p> 5967 * Type: int 5968 * @hide 5969 */ 5970 public static final String ADD_USERS_WHEN_LOCKED = "add_users_when_locked"; 5971 5972 /** 5973 * Setting whether the global gesture for enabling accessibility is enabled. 5974 * If this gesture is enabled the user will be able to perfrom it to enable 5975 * the accessibility state without visiting the settings app. 5976 * @hide 5977 */ 5978 public static final String ENABLE_ACCESSIBILITY_GLOBAL_GESTURE_ENABLED = 5979 "enable_accessibility_global_gesture_enabled"; 5980 5981 /** 5982 * Whether Airplane Mode is on. 5983 */ 5984 public static final String AIRPLANE_MODE_ON = "airplane_mode_on"; 5985 5986 /** 5987 * Whether Theater Mode is on. 5988 * {@hide} 5989 */ 5990 @SystemApi 5991 public static final String THEATER_MODE_ON = "theater_mode_on"; 5992 5993 /** 5994 * Constant for use in AIRPLANE_MODE_RADIOS to specify Bluetooth radio. 5995 */ 5996 public static final String RADIO_BLUETOOTH = "bluetooth"; 5997 5998 /** 5999 * Constant for use in AIRPLANE_MODE_RADIOS to specify Wi-Fi radio. 6000 */ 6001 public static final String RADIO_WIFI = "wifi"; 6002 6003 /** 6004 * {@hide} 6005 */ 6006 public static final String RADIO_WIMAX = "wimax"; 6007 /** 6008 * Constant for use in AIRPLANE_MODE_RADIOS to specify Cellular radio. 6009 */ 6010 public static final String RADIO_CELL = "cell"; 6011 6012 /** 6013 * Constant for use in AIRPLANE_MODE_RADIOS to specify NFC radio. 6014 */ 6015 public static final String RADIO_NFC = "nfc"; 6016 6017 /** 6018 * A comma separated list of radios that need to be disabled when airplane mode 6019 * is on. This overrides WIFI_ON and BLUETOOTH_ON, if Wi-Fi and bluetooth are 6020 * included in the comma separated list. 6021 */ 6022 public static final String AIRPLANE_MODE_RADIOS = "airplane_mode_radios"; 6023 6024 /** 6025 * A comma separated list of radios that should to be disabled when airplane mode 6026 * is on, but can be manually reenabled by the user. For example, if RADIO_WIFI is 6027 * added to both AIRPLANE_MODE_RADIOS and AIRPLANE_MODE_TOGGLEABLE_RADIOS, then Wifi 6028 * will be turned off when entering airplane mode, but the user will be able to reenable 6029 * Wifi in the Settings app. 6030 * 6031 * {@hide} 6032 */ 6033 public static final String AIRPLANE_MODE_TOGGLEABLE_RADIOS = "airplane_mode_toggleable_radios"; 6034 6035 /** 6036 * The policy for deciding when Wi-Fi should go to sleep (which will in 6037 * turn switch to using the mobile data as an Internet connection). 6038 * <p> 6039 * Set to one of {@link #WIFI_SLEEP_POLICY_DEFAULT}, 6040 * {@link #WIFI_SLEEP_POLICY_NEVER_WHILE_PLUGGED}, or 6041 * {@link #WIFI_SLEEP_POLICY_NEVER}. 6042 */ 6043 public static final String WIFI_SLEEP_POLICY = "wifi_sleep_policy"; 6044 6045 /** 6046 * Value for {@link #WIFI_SLEEP_POLICY} to use the default Wi-Fi sleep 6047 * policy, which is to sleep shortly after the turning off 6048 * according to the {@link #STAY_ON_WHILE_PLUGGED_IN} setting. 6049 */ 6050 public static final int WIFI_SLEEP_POLICY_DEFAULT = 0; 6051 6052 /** 6053 * Value for {@link #WIFI_SLEEP_POLICY} to use the default policy when 6054 * the device is on battery, and never go to sleep when the device is 6055 * plugged in. 6056 */ 6057 public static final int WIFI_SLEEP_POLICY_NEVER_WHILE_PLUGGED = 1; 6058 6059 /** 6060 * Value for {@link #WIFI_SLEEP_POLICY} to never go to sleep. 6061 */ 6062 public static final int WIFI_SLEEP_POLICY_NEVER = 2; 6063 6064 /** 6065 * Value to specify if the user prefers the date, time and time zone 6066 * to be automatically fetched from the network (NITZ). 1=yes, 0=no 6067 */ 6068 public static final String AUTO_TIME = "auto_time"; 6069 6070 /** 6071 * Value to specify if the user prefers the time zone 6072 * to be automatically fetched from the network (NITZ). 1=yes, 0=no 6073 */ 6074 public static final String AUTO_TIME_ZONE = "auto_time_zone"; 6075 6076 /** 6077 * URI for the car dock "in" event sound. 6078 * @hide 6079 */ 6080 public static final String CAR_DOCK_SOUND = "car_dock_sound"; 6081 6082 /** 6083 * URI for the car dock "out" event sound. 6084 * @hide 6085 */ 6086 public static final String CAR_UNDOCK_SOUND = "car_undock_sound"; 6087 6088 /** 6089 * URI for the desk dock "in" event sound. 6090 * @hide 6091 */ 6092 public static final String DESK_DOCK_SOUND = "desk_dock_sound"; 6093 6094 /** 6095 * URI for the desk dock "out" event sound. 6096 * @hide 6097 */ 6098 public static final String DESK_UNDOCK_SOUND = "desk_undock_sound"; 6099 6100 /** 6101 * Whether to play a sound for dock events. 6102 * @hide 6103 */ 6104 public static final String DOCK_SOUNDS_ENABLED = "dock_sounds_enabled"; 6105 6106 /** 6107 * URI for the "device locked" (keyguard shown) sound. 6108 * @hide 6109 */ 6110 public static final String LOCK_SOUND = "lock_sound"; 6111 6112 /** 6113 * URI for the "device unlocked" sound. 6114 * @hide 6115 */ 6116 public static final String UNLOCK_SOUND = "unlock_sound"; 6117 6118 /** 6119 * URI for the "device is trusted" sound, which is played when the device enters the trusted 6120 * state without unlocking. 6121 * @hide 6122 */ 6123 public static final String TRUSTED_SOUND = "trusted_sound"; 6124 6125 /** 6126 * URI for the low battery sound file. 6127 * @hide 6128 */ 6129 public static final String LOW_BATTERY_SOUND = "low_battery_sound"; 6130 6131 /** 6132 * Whether to play a sound for low-battery alerts. 6133 * @hide 6134 */ 6135 public static final String POWER_SOUNDS_ENABLED = "power_sounds_enabled"; 6136 6137 /** 6138 * URI for the "wireless charging started" sound. 6139 * @hide 6140 */ 6141 public static final String WIRELESS_CHARGING_STARTED_SOUND = 6142 "wireless_charging_started_sound"; 6143 6144 /** 6145 * Whether to play a sound for charging events. 6146 * @hide 6147 */ 6148 public static final String CHARGING_SOUNDS_ENABLED = "charging_sounds_enabled"; 6149 6150 /** 6151 * Whether we keep the device on while the device is plugged in. 6152 * Supported values are: 6153 * <ul> 6154 * <li>{@code 0} to never stay on while plugged in</li> 6155 * <li>{@link BatteryManager#BATTERY_PLUGGED_AC} to stay on for AC charger</li> 6156 * <li>{@link BatteryManager#BATTERY_PLUGGED_USB} to stay on for USB charger</li> 6157 * <li>{@link BatteryManager#BATTERY_PLUGGED_WIRELESS} to stay on for wireless charger</li> 6158 * </ul> 6159 * These values can be OR-ed together. 6160 */ 6161 public static final String STAY_ON_WHILE_PLUGGED_IN = "stay_on_while_plugged_in"; 6162 6163 /** 6164 * When the user has enable the option to have a "bug report" command 6165 * in the power menu. 6166 * @hide 6167 */ 6168 public static final String BUGREPORT_IN_POWER_MENU = "bugreport_in_power_menu"; 6169 6170 /** 6171 * Whether ADB is enabled. 6172 */ 6173 public static final String ADB_ENABLED = "adb_enabled"; 6174 6175 /** 6176 * Whether Views are allowed to save their attribute data. 6177 * @hide 6178 */ 6179 public static final String DEBUG_VIEW_ATTRIBUTES = "debug_view_attributes"; 6180 6181 /** 6182 * Whether assisted GPS should be enabled or not. 6183 * @hide 6184 */ 6185 public static final String ASSISTED_GPS_ENABLED = "assisted_gps_enabled"; 6186 6187 /** 6188 * Whether bluetooth is enabled/disabled 6189 * 0=disabled. 1=enabled. 6190 */ 6191 public static final String BLUETOOTH_ON = "bluetooth_on"; 6192 6193 /** 6194 * CDMA Cell Broadcast SMS 6195 * 0 = CDMA Cell Broadcast SMS disabled 6196 * 1 = CDMA Cell Broadcast SMS enabled 6197 * @hide 6198 */ 6199 public static final String CDMA_CELL_BROADCAST_SMS = 6200 "cdma_cell_broadcast_sms"; 6201 6202 /** 6203 * The CDMA roaming mode 0 = Home Networks, CDMA default 6204 * 1 = Roaming on Affiliated networks 6205 * 2 = Roaming on any networks 6206 * @hide 6207 */ 6208 public static final String CDMA_ROAMING_MODE = "roaming_settings"; 6209 6210 /** 6211 * The CDMA subscription mode 0 = RUIM/SIM (default) 6212 * 1 = NV 6213 * @hide 6214 */ 6215 public static final String CDMA_SUBSCRIPTION_MODE = "subscription_mode"; 6216 6217 /** Inactivity timeout to track mobile data activity. 6218 * 6219 * If set to a positive integer, it indicates the inactivity timeout value in seconds to 6220 * infer the data activity of mobile network. After a period of no activity on mobile 6221 * networks with length specified by the timeout, an {@code ACTION_DATA_ACTIVITY_CHANGE} 6222 * intent is fired to indicate a transition of network status from "active" to "idle". Any 6223 * subsequent activity on mobile networks triggers the firing of {@code 6224 * ACTION_DATA_ACTIVITY_CHANGE} intent indicating transition from "idle" to "active". 6225 * 6226 * Network activity refers to transmitting or receiving data on the network interfaces. 6227 * 6228 * Tracking is disabled if set to zero or negative value. 6229 * 6230 * @hide 6231 */ 6232 public static final String DATA_ACTIVITY_TIMEOUT_MOBILE = "data_activity_timeout_mobile"; 6233 6234 /** Timeout to tracking Wifi data activity. Same as {@code DATA_ACTIVITY_TIMEOUT_MOBILE} 6235 * but for Wifi network. 6236 * @hide 6237 */ 6238 public static final String DATA_ACTIVITY_TIMEOUT_WIFI = "data_activity_timeout_wifi"; 6239 6240 /** 6241 * Whether or not data roaming is enabled. (0 = false, 1 = true) 6242 */ 6243 public static final String DATA_ROAMING = "data_roaming"; 6244 6245 /** 6246 * The value passed to a Mobile DataConnection via bringUp which defines the 6247 * number of retries to preform when setting up the initial connection. The default 6248 * value defined in DataConnectionTrackerBase#DEFAULT_MDC_INITIAL_RETRY is currently 1. 6249 * @hide 6250 */ 6251 public static final String MDC_INITIAL_MAX_RETRY = "mdc_initial_max_retry"; 6252 6253 /** 6254 * Whether user has enabled development settings. 6255 */ 6256 public static final String DEVELOPMENT_SETTINGS_ENABLED = "development_settings_enabled"; 6257 6258 /** 6259 * Whether the device has been provisioned (0 = false, 1 = true) 6260 */ 6261 public static final String DEVICE_PROVISIONED = "device_provisioned"; 6262 6263 /** 6264 * The saved value for WindowManagerService.setForcedDisplayDensity(). 6265 * One integer in dpi. If unset, then use the real display density. 6266 * @hide 6267 */ 6268 public static final String DISPLAY_DENSITY_FORCED = "display_density_forced"; 6269 6270 /** 6271 * The saved value for WindowManagerService.setForcedDisplaySize(). 6272 * Two integers separated by a comma. If unset, then use the real display size. 6273 * @hide 6274 */ 6275 public static final String DISPLAY_SIZE_FORCED = "display_size_forced"; 6276 6277 /** 6278 * The saved value for WindowManagerService.setForcedDisplayScalingMode(). 6279 * 0 or unset if scaling is automatic, 1 if scaling is disabled. 6280 * @hide 6281 */ 6282 public static final String DISPLAY_SCALING_FORCE = "display_scaling_force"; 6283 6284 /** 6285 * The maximum size, in bytes, of a download that the download manager will transfer over 6286 * a non-wifi connection. 6287 * @hide 6288 */ 6289 public static final String DOWNLOAD_MAX_BYTES_OVER_MOBILE = 6290 "download_manager_max_bytes_over_mobile"; 6291 6292 /** 6293 * The recommended maximum size, in bytes, of a download that the download manager should 6294 * transfer over a non-wifi connection. Over this size, the use will be warned, but will 6295 * have the option to start the download over the mobile connection anyway. 6296 * @hide 6297 */ 6298 public static final String DOWNLOAD_RECOMMENDED_MAX_BYTES_OVER_MOBILE = 6299 "download_manager_recommended_max_bytes_over_mobile"; 6300 6301 /** 6302 * @deprecated Use {@link android.provider.Settings.Secure#INSTALL_NON_MARKET_APPS} instead 6303 */ 6304 @Deprecated 6305 public static final String INSTALL_NON_MARKET_APPS = Secure.INSTALL_NON_MARKET_APPS; 6306 6307 /** 6308 * Whether HDMI control shall be enabled. If disabled, no CEC/MHL command will be 6309 * sent or processed. (0 = false, 1 = true) 6310 * @hide 6311 */ 6312 public static final String HDMI_CONTROL_ENABLED = "hdmi_control_enabled"; 6313 6314 /** 6315 * Whether HDMI system audio is enabled. If enabled, TV internal speaker is muted, 6316 * and the output is redirected to AV Receiver connected via 6317 * {@Global#HDMI_SYSTEM_AUDIO_OUTPUT}. 6318 * @hide 6319 */ 6320 public static final String HDMI_SYSTEM_AUDIO_ENABLED = "hdmi_system_audio_enabled"; 6321 6322 /** 6323 * Whether TV will automatically turn on upon reception of the CEC command 6324 * <Text View On> or <Image View On>. (0 = false, 1 = true) 6325 * @hide 6326 */ 6327 public static final String HDMI_CONTROL_AUTO_WAKEUP_ENABLED = 6328 "hdmi_control_auto_wakeup_enabled"; 6329 6330 /** 6331 * Whether TV will also turn off other CEC devices when it goes to standby mode. 6332 * (0 = false, 1 = true) 6333 * @hide 6334 */ 6335 public static final String HDMI_CONTROL_AUTO_DEVICE_OFF_ENABLED = 6336 "hdmi_control_auto_device_off_enabled"; 6337 6338 /** 6339 * Whether to use the DHCP client from Lollipop and earlier instead of the newer Android DHCP 6340 * client. 6341 * (0 = false, 1 = true) 6342 * @hide 6343 */ 6344 public static final String LEGACY_DHCP_CLIENT = "legacy_dhcp_client"; 6345 6346 /** 6347 * Whether TV will switch to MHL port when a mobile device is plugged in. 6348 * (0 = false, 1 = true) 6349 * @hide 6350 */ 6351 public static final String MHL_INPUT_SWITCHING_ENABLED = "mhl_input_switching_enabled"; 6352 6353 /** 6354 * Whether TV will charge the mobile device connected at MHL port. (0 = false, 1 = true) 6355 * @hide 6356 */ 6357 public static final String MHL_POWER_CHARGE_ENABLED = "mhl_power_charge_enabled"; 6358 6359 /** 6360 * Whether mobile data connections are allowed by the user. See 6361 * ConnectivityManager for more info. 6362 * @hide 6363 */ 6364 public static final String MOBILE_DATA = "mobile_data"; 6365 6366 /** 6367 * Whether the mobile data connection should remain active even when higher 6368 * priority networks like WiFi are active, to help make network switching faster. 6369 * 6370 * See ConnectivityService for more info. 6371 * 6372 * (0 = disabled, 1 = enabled) 6373 * @hide 6374 */ 6375 public static final String MOBILE_DATA_ALWAYS_ON = "mobile_data_always_on"; 6376 6377 /** {@hide} */ 6378 public static final String NETSTATS_ENABLED = "netstats_enabled"; 6379 /** {@hide} */ 6380 public static final String NETSTATS_POLL_INTERVAL = "netstats_poll_interval"; 6381 /** {@hide} */ 6382 public static final String NETSTATS_TIME_CACHE_MAX_AGE = "netstats_time_cache_max_age"; 6383 /** {@hide} */ 6384 public static final String NETSTATS_GLOBAL_ALERT_BYTES = "netstats_global_alert_bytes"; 6385 /** {@hide} */ 6386 public static final String NETSTATS_SAMPLE_ENABLED = "netstats_sample_enabled"; 6387 6388 /** {@hide} */ 6389 public static final String NETSTATS_DEV_BUCKET_DURATION = "netstats_dev_bucket_duration"; 6390 /** {@hide} */ 6391 public static final String NETSTATS_DEV_PERSIST_BYTES = "netstats_dev_persist_bytes"; 6392 /** {@hide} */ 6393 public static final String NETSTATS_DEV_ROTATE_AGE = "netstats_dev_rotate_age"; 6394 /** {@hide} */ 6395 public static final String NETSTATS_DEV_DELETE_AGE = "netstats_dev_delete_age"; 6396 6397 /** {@hide} */ 6398 public static final String NETSTATS_UID_BUCKET_DURATION = "netstats_uid_bucket_duration"; 6399 /** {@hide} */ 6400 public static final String NETSTATS_UID_PERSIST_BYTES = "netstats_uid_persist_bytes"; 6401 /** {@hide} */ 6402 public static final String NETSTATS_UID_ROTATE_AGE = "netstats_uid_rotate_age"; 6403 /** {@hide} */ 6404 public static final String NETSTATS_UID_DELETE_AGE = "netstats_uid_delete_age"; 6405 6406 /** {@hide} */ 6407 public static final String NETSTATS_UID_TAG_BUCKET_DURATION = "netstats_uid_tag_bucket_duration"; 6408 /** {@hide} */ 6409 public static final String NETSTATS_UID_TAG_PERSIST_BYTES = "netstats_uid_tag_persist_bytes"; 6410 /** {@hide} */ 6411 public static final String NETSTATS_UID_TAG_ROTATE_AGE = "netstats_uid_tag_rotate_age"; 6412 /** {@hide} */ 6413 public static final String NETSTATS_UID_TAG_DELETE_AGE = "netstats_uid_tag_delete_age"; 6414 6415 /** 6416 * User preference for which network(s) should be used. Only the 6417 * connectivity service should touch this. 6418 */ 6419 public static final String NETWORK_PREFERENCE = "network_preference"; 6420 6421 /** 6422 * Which package name to use for network scoring. If null, or if the package is not a valid 6423 * scorer app, external network scores will neither be requested nor accepted. 6424 * @hide 6425 */ 6426 public static final String NETWORK_SCORER_APP = "network_scorer_app"; 6427 6428 /** 6429 * If the NITZ_UPDATE_DIFF time is exceeded then an automatic adjustment 6430 * to SystemClock will be allowed even if NITZ_UPDATE_SPACING has not been 6431 * exceeded. 6432 * @hide 6433 */ 6434 public static final String NITZ_UPDATE_DIFF = "nitz_update_diff"; 6435 6436 /** 6437 * The length of time in milli-seconds that automatic small adjustments to 6438 * SystemClock are ignored if NITZ_UPDATE_DIFF is not exceeded. 6439 * @hide 6440 */ 6441 public static final String NITZ_UPDATE_SPACING = "nitz_update_spacing"; 6442 6443 /** Preferred NTP server. {@hide} */ 6444 public static final String NTP_SERVER = "ntp_server"; 6445 /** Timeout in milliseconds to wait for NTP server. {@hide} */ 6446 public static final String NTP_TIMEOUT = "ntp_timeout"; 6447 6448 /** {@hide} */ 6449 public static final String STORAGE_BENCHMARK_INTERVAL = "storage_benchmark_interval"; 6450 6451 /** 6452 * Whether the package manager should send package verification broadcasts for verifiers to 6453 * review apps prior to installation. 6454 * 1 = request apps to be verified prior to installation, if a verifier exists. 6455 * 0 = do not verify apps before installation 6456 * @hide 6457 */ 6458 public static final String PACKAGE_VERIFIER_ENABLE = "package_verifier_enable"; 6459 6460 /** Timeout for package verification. 6461 * @hide */ 6462 public static final String PACKAGE_VERIFIER_TIMEOUT = "verifier_timeout"; 6463 6464 /** Default response code for package verification. 6465 * @hide */ 6466 public static final String PACKAGE_VERIFIER_DEFAULT_RESPONSE = "verifier_default_response"; 6467 6468 /** 6469 * Show package verification setting in the Settings app. 6470 * 1 = show (default) 6471 * 0 = hide 6472 * @hide 6473 */ 6474 public static final String PACKAGE_VERIFIER_SETTING_VISIBLE = "verifier_setting_visible"; 6475 6476 /** 6477 * Run package verification on apps installed through ADB/ADT/USB 6478 * 1 = perform package verification on ADB installs (default) 6479 * 0 = bypass package verification on ADB installs 6480 * @hide 6481 */ 6482 public static final String PACKAGE_VERIFIER_INCLUDE_ADB = "verifier_verify_adb_installs"; 6483 6484 /** 6485 * Time since last fstrim (milliseconds) after which we force one to happen 6486 * during device startup. If unset, the default is 3 days. 6487 * @hide 6488 */ 6489 public static final String FSTRIM_MANDATORY_INTERVAL = "fstrim_mandatory_interval"; 6490 6491 /** 6492 * The interval in milliseconds at which to check packet counts on the 6493 * mobile data interface when screen is on, to detect possible data 6494 * connection problems. 6495 * @hide 6496 */ 6497 public static final String PDP_WATCHDOG_POLL_INTERVAL_MS = 6498 "pdp_watchdog_poll_interval_ms"; 6499 6500 /** 6501 * The interval in milliseconds at which to check packet counts on the 6502 * mobile data interface when screen is off, to detect possible data 6503 * connection problems. 6504 * @hide 6505 */ 6506 public static final String PDP_WATCHDOG_LONG_POLL_INTERVAL_MS = 6507 "pdp_watchdog_long_poll_interval_ms"; 6508 6509 /** 6510 * The interval in milliseconds at which to check packet counts on the 6511 * mobile data interface after {@link #PDP_WATCHDOG_TRIGGER_PACKET_COUNT} 6512 * outgoing packets has been reached without incoming packets. 6513 * @hide 6514 */ 6515 public static final String PDP_WATCHDOG_ERROR_POLL_INTERVAL_MS = 6516 "pdp_watchdog_error_poll_interval_ms"; 6517 6518 /** 6519 * The number of outgoing packets sent without seeing an incoming packet 6520 * that triggers a countdown (of {@link #PDP_WATCHDOG_ERROR_POLL_COUNT} 6521 * device is logged to the event log 6522 * @hide 6523 */ 6524 public static final String PDP_WATCHDOG_TRIGGER_PACKET_COUNT = 6525 "pdp_watchdog_trigger_packet_count"; 6526 6527 /** 6528 * The number of polls to perform (at {@link #PDP_WATCHDOG_ERROR_POLL_INTERVAL_MS}) 6529 * after hitting {@link #PDP_WATCHDOG_TRIGGER_PACKET_COUNT} before 6530 * attempting data connection recovery. 6531 * @hide 6532 */ 6533 public static final String PDP_WATCHDOG_ERROR_POLL_COUNT = 6534 "pdp_watchdog_error_poll_count"; 6535 6536 /** 6537 * The number of failed PDP reset attempts before moving to something more 6538 * drastic: re-registering to the network. 6539 * @hide 6540 */ 6541 public static final String PDP_WATCHDOG_MAX_PDP_RESET_FAIL_COUNT = 6542 "pdp_watchdog_max_pdp_reset_fail_count"; 6543 6544 /** 6545 * A positive value indicates how often the SamplingProfiler 6546 * should take snapshots. Zero value means SamplingProfiler 6547 * is disabled. 6548 * 6549 * @hide 6550 */ 6551 public static final String SAMPLING_PROFILER_MS = "sampling_profiler_ms"; 6552 6553 /** 6554 * URL to open browser on to allow user to manage a prepay account 6555 * @hide 6556 */ 6557 public static final String SETUP_PREPAID_DATA_SERVICE_URL = 6558 "setup_prepaid_data_service_url"; 6559 6560 /** 6561 * URL to attempt a GET on to see if this is a prepay device 6562 * @hide 6563 */ 6564 public static final String SETUP_PREPAID_DETECTION_TARGET_URL = 6565 "setup_prepaid_detection_target_url"; 6566 6567 /** 6568 * Host to check for a redirect to after an attempt to GET 6569 * SETUP_PREPAID_DETECTION_TARGET_URL. (If we redirected there, 6570 * this is a prepaid device with zero balance.) 6571 * @hide 6572 */ 6573 public static final String SETUP_PREPAID_DETECTION_REDIR_HOST = 6574 "setup_prepaid_detection_redir_host"; 6575 6576 /** 6577 * The interval in milliseconds at which to check the number of SMS sent out without asking 6578 * for use permit, to limit the un-authorized SMS usage. 6579 * 6580 * @hide 6581 */ 6582 public static final String SMS_OUTGOING_CHECK_INTERVAL_MS = 6583 "sms_outgoing_check_interval_ms"; 6584 6585 /** 6586 * The number of outgoing SMS sent without asking for user permit (of {@link 6587 * #SMS_OUTGOING_CHECK_INTERVAL_MS} 6588 * 6589 * @hide 6590 */ 6591 public static final String SMS_OUTGOING_CHECK_MAX_COUNT = 6592 "sms_outgoing_check_max_count"; 6593 6594 /** 6595 * Used to disable SMS short code confirmation - defaults to true. 6596 * True indcates we will do the check, etc. Set to false to disable. 6597 * @see com.android.internal.telephony.SmsUsageMonitor 6598 * @hide 6599 */ 6600 public static final String SMS_SHORT_CODE_CONFIRMATION = "sms_short_code_confirmation"; 6601 6602 /** 6603 * Used to select which country we use to determine premium sms codes. 6604 * One of com.android.internal.telephony.SMSDispatcher.PREMIUM_RULE_USE_SIM, 6605 * com.android.internal.telephony.SMSDispatcher.PREMIUM_RULE_USE_NETWORK, 6606 * or com.android.internal.telephony.SMSDispatcher.PREMIUM_RULE_USE_BOTH. 6607 * @hide 6608 */ 6609 public static final String SMS_SHORT_CODE_RULE = "sms_short_code_rule"; 6610 6611 /** 6612 * Used to select TCP's default initial receiver window size in segments - defaults to a build config value 6613 * @hide 6614 */ 6615 public static final String TCP_DEFAULT_INIT_RWND = "tcp_default_init_rwnd"; 6616 6617 /** 6618 * Used to disable Tethering on a device - defaults to true 6619 * @hide 6620 */ 6621 public static final String TETHER_SUPPORTED = "tether_supported"; 6622 6623 /** 6624 * Used to require DUN APN on the device or not - defaults to a build config value 6625 * which defaults to false 6626 * @hide 6627 */ 6628 public static final String TETHER_DUN_REQUIRED = "tether_dun_required"; 6629 6630 /** 6631 * Used to hold a gservices-provisioned apn value for DUN. If set, or the 6632 * corresponding build config values are set it will override the APN DB 6633 * values. 6634 * Consists of a comma seperated list of strings: 6635 * "name,apn,proxy,port,username,password,server,mmsc,mmsproxy,mmsport,mcc,mnc,auth,type" 6636 * note that empty fields can be ommitted: "name,apn,,,,,,,,,310,260,,DUN" 6637 * @hide 6638 */ 6639 public static final String TETHER_DUN_APN = "tether_dun_apn"; 6640 6641 /** 6642 * USB Mass Storage Enabled 6643 */ 6644 public static final String USB_MASS_STORAGE_ENABLED = "usb_mass_storage_enabled"; 6645 6646 /** 6647 * If this setting is set (to anything), then all references 6648 * to Gmail on the device must change to Google Mail. 6649 */ 6650 public static final String USE_GOOGLE_MAIL = "use_google_mail"; 6651 6652 /** 6653 * Webview Data reduction proxy key. 6654 * @hide 6655 */ 6656 public static final String WEBVIEW_DATA_REDUCTION_PROXY_KEY = 6657 "webview_data_reduction_proxy_key"; 6658 6659 /** 6660 * Whether Wifi display is enabled/disabled 6661 * 0=disabled. 1=enabled. 6662 * @hide 6663 */ 6664 public static final String WIFI_DISPLAY_ON = "wifi_display_on"; 6665 6666 /** 6667 * Whether Wifi display certification mode is enabled/disabled 6668 * 0=disabled. 1=enabled. 6669 * @hide 6670 */ 6671 public static final String WIFI_DISPLAY_CERTIFICATION_ON = 6672 "wifi_display_certification_on"; 6673 6674 /** 6675 * WPS Configuration method used by Wifi display, this setting only 6676 * takes effect when WIFI_DISPLAY_CERTIFICATION_ON is 1 (enabled). 6677 * 6678 * Possible values are: 6679 * 6680 * WpsInfo.INVALID: use default WPS method chosen by framework 6681 * WpsInfo.PBC : use Push button 6682 * WpsInfo.KEYPAD : use Keypad 6683 * WpsInfo.DISPLAY: use Display 6684 * @hide 6685 */ 6686 public static final String WIFI_DISPLAY_WPS_CONFIG = 6687 "wifi_display_wps_config"; 6688 6689 /** 6690 * Whether to notify the user of open networks. 6691 * <p> 6692 * If not connected and the scan results have an open network, we will 6693 * put this notification up. If we attempt to connect to a network or 6694 * the open network(s) disappear, we remove the notification. When we 6695 * show the notification, we will not show it again for 6696 * {@link android.provider.Settings.Secure#WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY} time. 6697 */ 6698 public static final String WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON = 6699 "wifi_networks_available_notification_on"; 6700 /** 6701 * {@hide} 6702 */ 6703 public static final String WIMAX_NETWORKS_AVAILABLE_NOTIFICATION_ON = 6704 "wimax_networks_available_notification_on"; 6705 6706 /** 6707 * Delay (in seconds) before repeating the Wi-Fi networks available notification. 6708 * Connecting to a network will reset the timer. 6709 */ 6710 public static final String WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY = 6711 "wifi_networks_available_repeat_delay"; 6712 6713 /** 6714 * 802.11 country code in ISO 3166 format 6715 * @hide 6716 */ 6717 public static final String WIFI_COUNTRY_CODE = "wifi_country_code"; 6718 6719 /** 6720 * The interval in milliseconds to issue wake up scans when wifi needs 6721 * to connect. This is necessary to connect to an access point when 6722 * device is on the move and the screen is off. 6723 * @hide 6724 */ 6725 public static final String WIFI_FRAMEWORK_SCAN_INTERVAL_MS = 6726 "wifi_framework_scan_interval_ms"; 6727 6728 /** 6729 * The interval in milliseconds after which Wi-Fi is considered idle. 6730 * When idle, it is possible for the device to be switched from Wi-Fi to 6731 * the mobile data network. 6732 * @hide 6733 */ 6734 public static final String WIFI_IDLE_MS = "wifi_idle_ms"; 6735 6736 /** 6737 * When the number of open networks exceeds this number, the 6738 * least-recently-used excess networks will be removed. 6739 */ 6740 public static final String WIFI_NUM_OPEN_NETWORKS_KEPT = "wifi_num_open_networks_kept"; 6741 6742 /** 6743 * Whether the Wi-Fi should be on. Only the Wi-Fi service should touch this. 6744 */ 6745 public static final String WIFI_ON = "wifi_on"; 6746 6747 /** 6748 * Setting to allow scans to be enabled even wifi is turned off for connectivity. 6749 * @hide 6750 */ 6751 public static final String WIFI_SCAN_ALWAYS_AVAILABLE = 6752 "wifi_scan_always_enabled"; 6753 6754 /** 6755 * Settings to allow BLE scans to be enabled even when Bluetooth is turned off for 6756 * connectivity. 6757 * @hide 6758 */ 6759 public static final String BLE_SCAN_ALWAYS_AVAILABLE = 6760 "ble_scan_always_enabled"; 6761 6762 /** 6763 * Used to save the Wifi_ON state prior to tethering. 6764 * This state will be checked to restore Wifi after 6765 * the user turns off tethering. 6766 * 6767 * @hide 6768 */ 6769 public static final String WIFI_SAVED_STATE = "wifi_saved_state"; 6770 6771 /** 6772 * The interval in milliseconds to scan as used by the wifi supplicant 6773 * @hide 6774 */ 6775 public static final String WIFI_SUPPLICANT_SCAN_INTERVAL_MS = 6776 "wifi_supplicant_scan_interval_ms"; 6777 6778 /** 6779 * whether frameworks handles wifi auto-join 6780 * @hide 6781 */ 6782 public static final String WIFI_ENHANCED_AUTO_JOIN = 6783 "wifi_enhanced_auto_join"; 6784 6785 /** 6786 * whether settings show RSSI 6787 * @hide 6788 */ 6789 public static final String WIFI_NETWORK_SHOW_RSSI = 6790 "wifi_network_show_rssi"; 6791 6792 /** 6793 * The interval in milliseconds to scan at supplicant when p2p is connected 6794 * @hide 6795 */ 6796 public static final String WIFI_SCAN_INTERVAL_WHEN_P2P_CONNECTED_MS = 6797 "wifi_scan_interval_p2p_connected_ms"; 6798 6799 /** 6800 * Whether the Wi-Fi watchdog is enabled. 6801 */ 6802 public static final String WIFI_WATCHDOG_ON = "wifi_watchdog_on"; 6803 6804 /** 6805 * Setting to turn off poor network avoidance on Wi-Fi. Feature is enabled by default and 6806 * the setting needs to be set to 0 to disable it. 6807 * @hide 6808 */ 6809 public static final String WIFI_WATCHDOG_POOR_NETWORK_TEST_ENABLED = 6810 "wifi_watchdog_poor_network_test_enabled"; 6811 6812 /** 6813 * Setting to turn on suspend optimizations at screen off on Wi-Fi. Enabled by default and 6814 * needs to be set to 0 to disable it. 6815 * @hide 6816 */ 6817 public static final String WIFI_SUSPEND_OPTIMIZATIONS_ENABLED = 6818 "wifi_suspend_optimizations_enabled"; 6819 6820 /** 6821 * The maximum number of times we will retry a connection to an access 6822 * point for which we have failed in acquiring an IP address from DHCP. 6823 * A value of N means that we will make N+1 connection attempts in all. 6824 */ 6825 public static final String WIFI_MAX_DHCP_RETRY_COUNT = "wifi_max_dhcp_retry_count"; 6826 6827 /** 6828 * Maximum amount of time in milliseconds to hold a wakelock while waiting for mobile 6829 * data connectivity to be established after a disconnect from Wi-Fi. 6830 */ 6831 public static final String WIFI_MOBILE_DATA_TRANSITION_WAKELOCK_TIMEOUT_MS = 6832 "wifi_mobile_data_transition_wakelock_timeout_ms"; 6833 6834 /** 6835 * This setting controls whether WiFi configurations created by a Device Owner app 6836 * should be locked down (that is, be editable or removable only by the Device Owner App, 6837 * not even by Settings app). 6838 * This setting takes integer values. Non-zero values mean DO created configurations 6839 * are locked down. Value of zero means they are not. Default value in the absence of 6840 * actual value to this setting is 0. 6841 */ 6842 public static final String WIFI_DEVICE_OWNER_CONFIGS_LOCKDOWN = 6843 "wifi_device_owner_configs_lockdown"; 6844 6845 /** 6846 * The operational wifi frequency band 6847 * Set to one of {@link WifiManager#WIFI_FREQUENCY_BAND_AUTO}, 6848 * {@link WifiManager#WIFI_FREQUENCY_BAND_5GHZ} or 6849 * {@link WifiManager#WIFI_FREQUENCY_BAND_2GHZ} 6850 * 6851 * @hide 6852 */ 6853 public static final String WIFI_FREQUENCY_BAND = "wifi_frequency_band"; 6854 6855 /** 6856 * The Wi-Fi peer-to-peer device name 6857 * @hide 6858 */ 6859 public static final String WIFI_P2P_DEVICE_NAME = "wifi_p2p_device_name"; 6860 6861 /** 6862 * The min time between wifi disable and wifi enable 6863 * @hide 6864 */ 6865 public static final String WIFI_REENABLE_DELAY_MS = "wifi_reenable_delay"; 6866 6867 /** 6868 * Timeout for ephemeral networks when all known BSSIDs go out of range. We will disconnect 6869 * from an ephemeral network if there is no BSSID for that network with a non-null score that 6870 * has been seen in this time period. 6871 * 6872 * If this is less than or equal to zero, we use a more conservative behavior and only check 6873 * for a non-null score from the currently connected or target BSSID. 6874 * @hide 6875 */ 6876 public static final String WIFI_EPHEMERAL_OUT_OF_RANGE_TIMEOUT_MS = 6877 "wifi_ephemeral_out_of_range_timeout_ms"; 6878 6879 /** 6880 * The number of milliseconds to delay when checking for data stalls during 6881 * non-aggressive detection. (screen is turned off.) 6882 * @hide 6883 */ 6884 public static final String DATA_STALL_ALARM_NON_AGGRESSIVE_DELAY_IN_MS = 6885 "data_stall_alarm_non_aggressive_delay_in_ms"; 6886 6887 /** 6888 * The number of milliseconds to delay when checking for data stalls during 6889 * aggressive detection. (screen on or suspected data stall) 6890 * @hide 6891 */ 6892 public static final String DATA_STALL_ALARM_AGGRESSIVE_DELAY_IN_MS = 6893 "data_stall_alarm_aggressive_delay_in_ms"; 6894 6895 /** 6896 * The number of milliseconds to allow the provisioning apn to remain active 6897 * @hide 6898 */ 6899 public static final String PROVISIONING_APN_ALARM_DELAY_IN_MS = 6900 "provisioning_apn_alarm_delay_in_ms"; 6901 6902 /** 6903 * The interval in milliseconds at which to check gprs registration 6904 * after the first registration mismatch of gprs and voice service, 6905 * to detect possible data network registration problems. 6906 * 6907 * @hide 6908 */ 6909 public static final String GPRS_REGISTER_CHECK_PERIOD_MS = 6910 "gprs_register_check_period_ms"; 6911 6912 /** 6913 * Nonzero causes Log.wtf() to crash. 6914 * @hide 6915 */ 6916 public static final String WTF_IS_FATAL = "wtf_is_fatal"; 6917 6918 /** 6919 * Ringer mode. This is used internally, changing this value will not 6920 * change the ringer mode. See AudioManager. 6921 */ 6922 public static final String MODE_RINGER = "mode_ringer"; 6923 6924 /** 6925 * Overlay display devices setting. 6926 * The associated value is a specially formatted string that describes the 6927 * size and density of simulated secondary display devices. 6928 * <p> 6929 * Format: {width}x{height}/{dpi};... 6930 * </p><p> 6931 * Example: 6932 * <ul> 6933 * <li><code>1280x720/213</code>: make one overlay that is 1280x720 at 213dpi.</li> 6934 * <li><code>1920x1080/320;1280x720/213</code>: make two overlays, the first 6935 * at 1080p and the second at 720p.</li> 6936 * <li>If the value is empty, then no overlay display devices are created.</li> 6937 * </ul></p> 6938 * 6939 * @hide 6940 */ 6941 public static final String OVERLAY_DISPLAY_DEVICES = "overlay_display_devices"; 6942 6943 /** 6944 * Threshold values for the duration and level of a discharge cycle, 6945 * under which we log discharge cycle info. 6946 * 6947 * @hide 6948 */ 6949 public static final String 6950 BATTERY_DISCHARGE_DURATION_THRESHOLD = "battery_discharge_duration_threshold"; 6951 6952 /** @hide */ 6953 public static final String BATTERY_DISCHARGE_THRESHOLD = "battery_discharge_threshold"; 6954 6955 /** 6956 * Flag for allowing ActivityManagerService to send ACTION_APP_ERROR 6957 * intents on application crashes and ANRs. If this is disabled, the 6958 * crash/ANR dialog will never display the "Report" button. 6959 * <p> 6960 * Type: int (0 = disallow, 1 = allow) 6961 * 6962 * @hide 6963 */ 6964 public static final String SEND_ACTION_APP_ERROR = "send_action_app_error"; 6965 6966 /** 6967 * Maximum age of entries kept by {@link DropBoxManager}. 6968 * 6969 * @hide 6970 */ 6971 public static final String DROPBOX_AGE_SECONDS = "dropbox_age_seconds"; 6972 6973 /** 6974 * Maximum number of entry files which {@link DropBoxManager} will keep 6975 * around. 6976 * 6977 * @hide 6978 */ 6979 public static final String DROPBOX_MAX_FILES = "dropbox_max_files"; 6980 6981 /** 6982 * Maximum amount of disk space used by {@link DropBoxManager} no matter 6983 * what. 6984 * 6985 * @hide 6986 */ 6987 public static final String DROPBOX_QUOTA_KB = "dropbox_quota_kb"; 6988 6989 /** 6990 * Percent of free disk (excluding reserve) which {@link DropBoxManager} 6991 * will use. 6992 * 6993 * @hide 6994 */ 6995 public static final String DROPBOX_QUOTA_PERCENT = "dropbox_quota_percent"; 6996 6997 /** 6998 * Percent of total disk which {@link DropBoxManager} will never dip 6999 * into. 7000 * 7001 * @hide 7002 */ 7003 public static final String DROPBOX_RESERVE_PERCENT = "dropbox_reserve_percent"; 7004 7005 /** 7006 * Prefix for per-tag dropbox disable/enable settings. 7007 * 7008 * @hide 7009 */ 7010 public static final String DROPBOX_TAG_PREFIX = "dropbox:"; 7011 7012 /** 7013 * Lines of logcat to include with system crash/ANR/etc. reports, as a 7014 * prefix of the dropbox tag of the report type. For example, 7015 * "logcat_for_system_server_anr" controls the lines of logcat captured 7016 * with system server ANR reports. 0 to disable. 7017 * 7018 * @hide 7019 */ 7020 public static final String ERROR_LOGCAT_PREFIX = "logcat_for_"; 7021 7022 /** 7023 * The interval in minutes after which the amount of free storage left 7024 * on the device is logged to the event log 7025 * 7026 * @hide 7027 */ 7028 public static final String SYS_FREE_STORAGE_LOG_INTERVAL = "sys_free_storage_log_interval"; 7029 7030 /** 7031 * Threshold for the amount of change in disk free space required to 7032 * report the amount of free space. Used to prevent spamming the logs 7033 * when the disk free space isn't changing frequently. 7034 * 7035 * @hide 7036 */ 7037 public static final String 7038 DISK_FREE_CHANGE_REPORTING_THRESHOLD = "disk_free_change_reporting_threshold"; 7039 7040 /** 7041 * Minimum percentage of free storage on the device that is used to 7042 * determine if the device is running low on storage. The default is 10. 7043 * <p> 7044 * Say this value is set to 10, the device is considered running low on 7045 * storage if 90% or more of the device storage is filled up. 7046 * 7047 * @hide 7048 */ 7049 public static final String 7050 SYS_STORAGE_THRESHOLD_PERCENTAGE = "sys_storage_threshold_percentage"; 7051 7052 /** 7053 * Maximum byte size of the low storage threshold. This is to ensure 7054 * that {@link #SYS_STORAGE_THRESHOLD_PERCENTAGE} does not result in an 7055 * overly large threshold for large storage devices. Currently this must 7056 * be less than 2GB. This default is 500MB. 7057 * 7058 * @hide 7059 */ 7060 public static final String 7061 SYS_STORAGE_THRESHOLD_MAX_BYTES = "sys_storage_threshold_max_bytes"; 7062 7063 /** 7064 * Minimum bytes of free storage on the device before the data partition 7065 * is considered full. By default, 1 MB is reserved to avoid system-wide 7066 * SQLite disk full exceptions. 7067 * 7068 * @hide 7069 */ 7070 public static final String 7071 SYS_STORAGE_FULL_THRESHOLD_BYTES = "sys_storage_full_threshold_bytes"; 7072 7073 /** 7074 * The maximum reconnect delay for short network outages or when the 7075 * network is suspended due to phone use. 7076 * 7077 * @hide 7078 */ 7079 public static final String 7080 SYNC_MAX_RETRY_DELAY_IN_SECONDS = "sync_max_retry_delay_in_seconds"; 7081 7082 /** 7083 * The number of milliseconds to delay before sending out 7084 * {@link ConnectivityManager#CONNECTIVITY_ACTION} broadcasts. Ignored. 7085 * 7086 * @hide 7087 */ 7088 public static final String CONNECTIVITY_CHANGE_DELAY = "connectivity_change_delay"; 7089 7090 7091 /** 7092 * Network sampling interval, in seconds. We'll generate link information 7093 * about bytes/packets sent and error rates based on data sampled in this interval 7094 * 7095 * @hide 7096 */ 7097 7098 public static final String CONNECTIVITY_SAMPLING_INTERVAL_IN_SECONDS = 7099 "connectivity_sampling_interval_in_seconds"; 7100 7101 /** 7102 * The series of successively longer delays used in retrying to download PAC file. 7103 * Last delay is used between successful PAC downloads. 7104 * 7105 * @hide 7106 */ 7107 public static final String PAC_CHANGE_DELAY = "pac_change_delay"; 7108 7109 /** 7110 * Setting to turn off captive portal detection. Feature is enabled by 7111 * default and the setting needs to be set to 0 to disable it. 7112 * 7113 * @hide 7114 */ 7115 public static final String 7116 CAPTIVE_PORTAL_DETECTION_ENABLED = "captive_portal_detection_enabled"; 7117 7118 /** 7119 * The server used for captive portal detection upon a new conection. A 7120 * 204 response code from the server is used for validation. 7121 * 7122 * @hide 7123 */ 7124 public static final String CAPTIVE_PORTAL_SERVER = "captive_portal_server"; 7125 7126 /** 7127 * Whether network service discovery is enabled. 7128 * 7129 * @hide 7130 */ 7131 public static final String NSD_ON = "nsd_on"; 7132 7133 /** 7134 * Let user pick default install location. 7135 * 7136 * @hide 7137 */ 7138 public static final String SET_INSTALL_LOCATION = "set_install_location"; 7139 7140 /** 7141 * Default install location value. 7142 * 0 = auto, let system decide 7143 * 1 = internal 7144 * 2 = sdcard 7145 * @hide 7146 */ 7147 public static final String DEFAULT_INSTALL_LOCATION = "default_install_location"; 7148 7149 /** 7150 * ms during which to consume extra events related to Inet connection 7151 * condition after a transtion to fully-connected 7152 * 7153 * @hide 7154 */ 7155 public static final String 7156 INET_CONDITION_DEBOUNCE_UP_DELAY = "inet_condition_debounce_up_delay"; 7157 7158 /** 7159 * ms during which to consume extra events related to Inet connection 7160 * condtion after a transtion to partly-connected 7161 * 7162 * @hide 7163 */ 7164 public static final String 7165 INET_CONDITION_DEBOUNCE_DOWN_DELAY = "inet_condition_debounce_down_delay"; 7166 7167 /** {@hide} */ 7168 public static final String 7169 READ_EXTERNAL_STORAGE_ENFORCED_DEFAULT = "read_external_storage_enforced_default"; 7170 7171 /** 7172 * Host name and port for global http proxy. Uses ':' seperator for 7173 * between host and port. 7174 */ 7175 public static final String HTTP_PROXY = "http_proxy"; 7176 7177 /** 7178 * Host name for global http proxy. Set via ConnectivityManager. 7179 * 7180 * @hide 7181 */ 7182 public static final String GLOBAL_HTTP_PROXY_HOST = "global_http_proxy_host"; 7183 7184 /** 7185 * Integer host port for global http proxy. Set via ConnectivityManager. 7186 * 7187 * @hide 7188 */ 7189 public static final String GLOBAL_HTTP_PROXY_PORT = "global_http_proxy_port"; 7190 7191 /** 7192 * Exclusion list for global proxy. This string contains a list of 7193 * comma-separated domains where the global proxy does not apply. 7194 * Domains should be listed in a comma- separated list. Example of 7195 * acceptable formats: ".domain1.com,my.domain2.com" Use 7196 * ConnectivityManager to set/get. 7197 * 7198 * @hide 7199 */ 7200 public static final String 7201 GLOBAL_HTTP_PROXY_EXCLUSION_LIST = "global_http_proxy_exclusion_list"; 7202 7203 /** 7204 * The location PAC File for the proxy. 7205 * @hide 7206 */ 7207 public static final String 7208 GLOBAL_HTTP_PROXY_PAC = "global_proxy_pac_url"; 7209 7210 /** 7211 * Enables the UI setting to allow the user to specify the global HTTP 7212 * proxy and associated exclusion list. 7213 * 7214 * @hide 7215 */ 7216 public static final String SET_GLOBAL_HTTP_PROXY = "set_global_http_proxy"; 7217 7218 /** 7219 * Setting for default DNS in case nobody suggests one 7220 * 7221 * @hide 7222 */ 7223 public static final String DEFAULT_DNS_SERVER = "default_dns_server"; 7224 7225 /** {@hide} */ 7226 public static final String 7227 BLUETOOTH_HEADSET_PRIORITY_PREFIX = "bluetooth_headset_priority_"; 7228 /** {@hide} */ 7229 public static final String 7230 BLUETOOTH_A2DP_SINK_PRIORITY_PREFIX = "bluetooth_a2dp_sink_priority_"; 7231 /** {@hide} */ 7232 public static final String 7233 BLUETOOTH_INPUT_DEVICE_PRIORITY_PREFIX = "bluetooth_input_device_priority_"; 7234 /** {@hide} */ 7235 public static final String 7236 BLUETOOTH_MAP_PRIORITY_PREFIX = "bluetooth_map_priority_"; 7237 /** {@hide} */ 7238 public static final String 7239 BLUETOOTH_SAP_PRIORITY_PREFIX = "bluetooth_sap_priority_"; 7240 7241 /** 7242 * Device Idle (Doze) specific settings. 7243 * This is encoded as a key=value list, separated by commas. Ex: 7244 * 7245 * "inactive_timeout=60000,sensing_timeout=400000" 7246 * 7247 * The following keys are supported: 7248 * 7249 * <pre> 7250 * inactive_to (long) 7251 * sensing_to (long) 7252 * motion_inactive_to (long) 7253 * idle_after_inactive_to (long) 7254 * idle_pending_to (long) 7255 * max_idle_pending_to (long) 7256 * idle_pending_factor (float) 7257 * idle_to (long) 7258 * max_idle_to (long) 7259 * idle_factor (float) 7260 * min_time_to_alarm (long) 7261 * max_temp_app_whitelist_duration (long) 7262 * </pre> 7263 * 7264 * <p> 7265 * Type: string 7266 * @hide 7267 * @see com.android.server.DeviceIdleController.Constants 7268 */ 7269 public static final String DEVICE_IDLE_CONSTANTS = "device_idle_constants"; 7270 7271 /** 7272 * App standby (app idle) specific settings. 7273 * This is encoded as a key=value list, separated by commas. Ex: 7274 * 7275 * "idle_duration=5000,parole_interval=4500" 7276 * 7277 * The following keys are supported: 7278 * 7279 * <pre> 7280 * idle_duration (long) 7281 * wallclock_threshold (long) 7282 * parole_interval (long) 7283 * parole_duration (long) 7284 * </pre> 7285 * 7286 * <p> 7287 * Type: string 7288 * @hide 7289 * @see com.android.server.usage.UsageStatsService.SettingsObserver 7290 */ 7291 public static final String APP_IDLE_CONSTANTS = "app_idle_constants"; 7292 7293 /** 7294 * Alarm manager specific settings. 7295 * This is encoded as a key=value list, separated by commas. Ex: 7296 * 7297 * "min_futurity=5000,allow_while_idle_short_time=4500" 7298 * 7299 * The following keys are supported: 7300 * 7301 * <pre> 7302 * min_futurity (long) 7303 * min_interval (long) 7304 * allow_while_idle_short_time (long) 7305 * allow_while_idle_long_time (long) 7306 * allow_while_idle_whitelist_duration (long) 7307 * </pre> 7308 * 7309 * <p> 7310 * Type: string 7311 * @hide 7312 * @see com.android.server.AlarmManagerService.Constants 7313 */ 7314 public static final String ALARM_MANAGER_CONSTANTS = "alarm_manager_constants"; 7315 7316 /** 7317 * Get the key that retrieves a bluetooth headset's priority. 7318 * @hide 7319 */ getBluetoothHeadsetPriorityKey(String address)7320 public static final String getBluetoothHeadsetPriorityKey(String address) { 7321 return BLUETOOTH_HEADSET_PRIORITY_PREFIX + address.toUpperCase(Locale.ROOT); 7322 } 7323 7324 /** 7325 * Get the key that retrieves a bluetooth a2dp sink's priority. 7326 * @hide 7327 */ getBluetoothA2dpSinkPriorityKey(String address)7328 public static final String getBluetoothA2dpSinkPriorityKey(String address) { 7329 return BLUETOOTH_A2DP_SINK_PRIORITY_PREFIX + address.toUpperCase(Locale.ROOT); 7330 } 7331 7332 /** 7333 * Get the key that retrieves a bluetooth Input Device's priority. 7334 * @hide 7335 */ getBluetoothInputDevicePriorityKey(String address)7336 public static final String getBluetoothInputDevicePriorityKey(String address) { 7337 return BLUETOOTH_INPUT_DEVICE_PRIORITY_PREFIX + address.toUpperCase(Locale.ROOT); 7338 } 7339 7340 /** 7341 * Get the key that retrieves a bluetooth map priority. 7342 * @hide 7343 */ getBluetoothMapPriorityKey(String address)7344 public static final String getBluetoothMapPriorityKey(String address) { 7345 return BLUETOOTH_MAP_PRIORITY_PREFIX + address.toUpperCase(Locale.ROOT); 7346 } 7347 7348 /** 7349 * Get the key that retrieves a bluetooth map priority. 7350 * @hide 7351 */ getBluetoothSapPriorityKey(String address)7352 public static final String getBluetoothSapPriorityKey(String address) { 7353 return BLUETOOTH_SAP_PRIORITY_PREFIX + address.toUpperCase(Locale.ROOT); 7354 } 7355 7356 /** 7357 * Scaling factor for normal window animations. Setting to 0 will 7358 * disable window animations. 7359 */ 7360 public static final String WINDOW_ANIMATION_SCALE = "window_animation_scale"; 7361 7362 /** 7363 * Scaling factor for activity transition animations. Setting to 0 will 7364 * disable window animations. 7365 */ 7366 public static final String TRANSITION_ANIMATION_SCALE = "transition_animation_scale"; 7367 7368 /** 7369 * Scaling factor for Animator-based animations. This affects both the 7370 * start delay and duration of all such animations. Setting to 0 will 7371 * cause animations to end immediately. The default value is 1. 7372 */ 7373 public static final String ANIMATOR_DURATION_SCALE = "animator_duration_scale"; 7374 7375 /** 7376 * Scaling factor for normal window animations. Setting to 0 will 7377 * disable window animations. 7378 * 7379 * @hide 7380 */ 7381 public static final String FANCY_IME_ANIMATIONS = "fancy_ime_animations"; 7382 7383 /** 7384 * If 0, the compatibility mode is off for all applications. 7385 * If 1, older applications run under compatibility mode. 7386 * TODO: remove this settings before code freeze (bug/1907571) 7387 * @hide 7388 */ 7389 public static final String COMPATIBILITY_MODE = "compatibility_mode"; 7390 7391 /** 7392 * CDMA only settings 7393 * Emergency Tone 0 = Off 7394 * 1 = Alert 7395 * 2 = Vibrate 7396 * @hide 7397 */ 7398 public static final String EMERGENCY_TONE = "emergency_tone"; 7399 7400 /** 7401 * CDMA only settings 7402 * Whether the auto retry is enabled. The value is 7403 * boolean (1 or 0). 7404 * @hide 7405 */ 7406 public static final String CALL_AUTO_RETRY = "call_auto_retry"; 7407 7408 /** 7409 * See RIL_PreferredNetworkType in ril.h 7410 * @hide 7411 */ 7412 public static final String PREFERRED_NETWORK_MODE = 7413 "preferred_network_mode"; 7414 7415 /** 7416 * Name of an application package to be debugged. 7417 */ 7418 public static final String DEBUG_APP = "debug_app"; 7419 7420 /** 7421 * If 1, when launching DEBUG_APP it will wait for the debugger before 7422 * starting user code. If 0, it will run normally. 7423 */ 7424 public static final String WAIT_FOR_DEBUGGER = "wait_for_debugger"; 7425 7426 /** 7427 * Control whether the process CPU usage meter should be shown. 7428 */ 7429 public static final String SHOW_PROCESSES = "show_processes"; 7430 7431 /** 7432 * If 1 low power mode is enabled. 7433 * @hide 7434 */ 7435 public static final String LOW_POWER_MODE = "low_power"; 7436 7437 /** 7438 * Battery level [1-99] at which low power mode automatically turns on. 7439 * If 0, it will not automatically turn on. 7440 * @hide 7441 */ 7442 public static final String LOW_POWER_MODE_TRIGGER_LEVEL = "low_power_trigger_level"; 7443 7444 /** 7445 * If 1, the activity manager will aggressively finish activities and 7446 * processes as soon as they are no longer needed. If 0, the normal 7447 * extended lifetime is used. 7448 */ 7449 public static final String ALWAYS_FINISH_ACTIVITIES = "always_finish_activities"; 7450 7451 /** 7452 * Use Dock audio output for media: 7453 * 0 = disabled 7454 * 1 = enabled 7455 * @hide 7456 */ 7457 public static final String DOCK_AUDIO_MEDIA_ENABLED = "dock_audio_media_enabled"; 7458 7459 /** 7460 * Persisted safe headphone volume management state by AudioService 7461 * @hide 7462 */ 7463 public static final String AUDIO_SAFE_VOLUME_STATE = "audio_safe_volume_state"; 7464 7465 /** 7466 * URL for tzinfo (time zone) updates 7467 * @hide 7468 */ 7469 public static final String TZINFO_UPDATE_CONTENT_URL = "tzinfo_content_url"; 7470 7471 /** 7472 * URL for tzinfo (time zone) update metadata 7473 * @hide 7474 */ 7475 public static final String TZINFO_UPDATE_METADATA_URL = "tzinfo_metadata_url"; 7476 7477 /** 7478 * URL for selinux (mandatory access control) updates 7479 * @hide 7480 */ 7481 public static final String SELINUX_UPDATE_CONTENT_URL = "selinux_content_url"; 7482 7483 /** 7484 * URL for selinux (mandatory access control) update metadata 7485 * @hide 7486 */ 7487 public static final String SELINUX_UPDATE_METADATA_URL = "selinux_metadata_url"; 7488 7489 /** 7490 * URL for sms short code updates 7491 * @hide 7492 */ 7493 public static final String SMS_SHORT_CODES_UPDATE_CONTENT_URL = 7494 "sms_short_codes_content_url"; 7495 7496 /** 7497 * URL for sms short code update metadata 7498 * @hide 7499 */ 7500 public static final String SMS_SHORT_CODES_UPDATE_METADATA_URL = 7501 "sms_short_codes_metadata_url"; 7502 7503 /** 7504 * URL for cert pinlist updates 7505 * @hide 7506 */ 7507 public static final String CERT_PIN_UPDATE_CONTENT_URL = "cert_pin_content_url"; 7508 7509 /** 7510 * URL for cert pinlist updates 7511 * @hide 7512 */ 7513 public static final String CERT_PIN_UPDATE_METADATA_URL = "cert_pin_metadata_url"; 7514 7515 /** 7516 * URL for intent firewall updates 7517 * @hide 7518 */ 7519 public static final String INTENT_FIREWALL_UPDATE_CONTENT_URL = 7520 "intent_firewall_content_url"; 7521 7522 /** 7523 * URL for intent firewall update metadata 7524 * @hide 7525 */ 7526 public static final String INTENT_FIREWALL_UPDATE_METADATA_URL = 7527 "intent_firewall_metadata_url"; 7528 7529 /** 7530 * SELinux enforcement status. If 0, permissive; if 1, enforcing. 7531 * @hide 7532 */ 7533 public static final String SELINUX_STATUS = "selinux_status"; 7534 7535 /** 7536 * Developer setting to force RTL layout. 7537 * @hide 7538 */ 7539 public static final String DEVELOPMENT_FORCE_RTL = "debug.force_rtl"; 7540 7541 /** 7542 * Milliseconds after screen-off after which low battery sounds will be silenced. 7543 * 7544 * If zero, battery sounds will always play. 7545 * Defaults to @integer/def_low_battery_sound_timeout in SettingsProvider. 7546 * 7547 * @hide 7548 */ 7549 public static final String LOW_BATTERY_SOUND_TIMEOUT = "low_battery_sound_timeout"; 7550 7551 /** 7552 * Milliseconds to wait before bouncing Wi-Fi after settings is restored. Note that after 7553 * the caller is done with this, they should call {@link ContentResolver#delete} to 7554 * clean up any value that they may have written. 7555 * 7556 * @hide 7557 */ 7558 public static final String WIFI_BOUNCE_DELAY_OVERRIDE_MS = "wifi_bounce_delay_override_ms"; 7559 7560 /** 7561 * Defines global runtime overrides to window policy. 7562 * 7563 * See {@link com.android.server.policy.PolicyControl} for value format. 7564 * 7565 * @hide 7566 */ 7567 public static final String POLICY_CONTROL = "policy_control"; 7568 7569 /** 7570 * Defines global zen mode. ZEN_MODE_OFF, ZEN_MODE_IMPORTANT_INTERRUPTIONS, 7571 * or ZEN_MODE_NO_INTERRUPTIONS. 7572 * 7573 * @hide 7574 */ 7575 public static final String ZEN_MODE = "zen_mode"; 7576 7577 /** @hide */ public static final int ZEN_MODE_OFF = 0; 7578 /** @hide */ public static final int ZEN_MODE_IMPORTANT_INTERRUPTIONS = 1; 7579 /** @hide */ public static final int ZEN_MODE_NO_INTERRUPTIONS = 2; 7580 /** @hide */ public static final int ZEN_MODE_ALARMS = 3; 7581 zenModeToString(int mode)7582 /** @hide */ public static String zenModeToString(int mode) { 7583 if (mode == ZEN_MODE_IMPORTANT_INTERRUPTIONS) return "ZEN_MODE_IMPORTANT_INTERRUPTIONS"; 7584 if (mode == ZEN_MODE_ALARMS) return "ZEN_MODE_ALARMS"; 7585 if (mode == ZEN_MODE_NO_INTERRUPTIONS) return "ZEN_MODE_NO_INTERRUPTIONS"; 7586 return "ZEN_MODE_OFF"; 7587 } 7588 isValidZenMode(int value)7589 /** @hide */ public static boolean isValidZenMode(int value) { 7590 switch (value) { 7591 case Global.ZEN_MODE_OFF: 7592 case Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS: 7593 case Global.ZEN_MODE_ALARMS: 7594 case Global.ZEN_MODE_NO_INTERRUPTIONS: 7595 return true; 7596 default: 7597 return false; 7598 } 7599 } 7600 7601 /** 7602 * Value of the ringer before entering zen mode. 7603 * 7604 * @hide 7605 */ 7606 public static final String ZEN_MODE_RINGER_LEVEL = "zen_mode_ringer_level"; 7607 7608 /** 7609 * Opaque value, changes when persisted zen mode configuration changes. 7610 * 7611 * @hide 7612 */ 7613 public static final String ZEN_MODE_CONFIG_ETAG = "zen_mode_config_etag"; 7614 7615 /** 7616 * Defines global heads up toggle. One of HEADS_UP_OFF, HEADS_UP_ON. 7617 * 7618 * @hide 7619 */ 7620 public static final String HEADS_UP_NOTIFICATIONS_ENABLED = 7621 "heads_up_notifications_enabled"; 7622 7623 /** @hide */ public static final int HEADS_UP_OFF = 0; 7624 /** @hide */ public static final int HEADS_UP_ON = 1; 7625 7626 /** 7627 * The name of the device 7628 * 7629 * @hide 7630 */ 7631 public static final String DEVICE_NAME = "device_name"; 7632 7633 /** 7634 * Whether it should be possible to create a guest user on the device. 7635 * <p> 7636 * Type: int (0 for disabled, 1 for enabled) 7637 * @hide 7638 */ 7639 public static final String GUEST_USER_ENABLED = "guest_user_enabled"; 7640 7641 /** 7642 * Whether the NetworkScoringService has been first initialized. 7643 * <p> 7644 * Type: int (0 for false, 1 for true) 7645 * @hide 7646 */ 7647 public static final String NETWORK_SCORING_PROVISIONED = "network_scoring_provisioned"; 7648 7649 /** 7650 * Whether the user wants to be prompted for password to decrypt the device on boot. 7651 * This only matters if the storage is encrypted. 7652 * <p> 7653 * Type: int (0 for false, 1 for true) 7654 * @hide 7655 */ 7656 public static final String REQUIRE_PASSWORD_TO_DECRYPT = "require_password_to_decrypt"; 7657 7658 /** 7659 * Whether the Volte/VT is enabled 7660 * <p> 7661 * Type: int (0 for false, 1 for true) 7662 * @hide 7663 */ 7664 public static final String ENHANCED_4G_MODE_ENABLED = "volte_vt_enabled"; 7665 7666 /** 7667 * Whether WFC is enabled 7668 * <p> 7669 * Type: int (0 for false, 1 for true) 7670 * 7671 * @hide 7672 */ 7673 public static final String WFC_IMS_ENABLED = "wfc_ims_enabled"; 7674 7675 /** 7676 * WFC Mode. 7677 * <p> 7678 * Type: int - 2=Wi-Fi preferred, 1=Cellular preferred, 0=Wi-Fi only 7679 * 7680 * @hide 7681 */ 7682 public static final String WFC_IMS_MODE = "wfc_ims_mode"; 7683 7684 /** 7685 * Whether WFC roaming is enabled 7686 * <p> 7687 * Type: int (0 for false, 1 for true) 7688 * 7689 * @hide 7690 */ 7691 public static final String WFC_IMS_ROAMING_ENABLED = "wfc_ims_roaming_enabled"; 7692 7693 /** 7694 * Whether user can enable/disable LTE as a preferred network. A carrier might control 7695 * this via gservices, OMA-DM, carrier app, etc. 7696 * <p> 7697 * Type: int (0 for false, 1 for true) 7698 * @hide 7699 */ 7700 public static final String LTE_SERVICE_FORCED = "lte_service_forced"; 7701 7702 /** 7703 * Settings to backup. This is here so that it's in the same place as the settings 7704 * keys and easy to update. 7705 * 7706 * These keys may be mentioned in the SETTINGS_TO_BACKUP arrays in System 7707 * and Secure as well. This is because those tables drive both backup and 7708 * restore, and restore needs to properly whitelist keys that used to live 7709 * in those namespaces. The keys will only actually be backed up / restored 7710 * if they are also mentioned in this table (Global.SETTINGS_TO_BACKUP). 7711 * 7712 * NOTE: Settings are backed up and restored in the order they appear 7713 * in this array. If you have one setting depending on another, 7714 * make sure that they are ordered appropriately. 7715 * 7716 * @hide 7717 */ 7718 public static final String[] SETTINGS_TO_BACKUP = { 7719 BUGREPORT_IN_POWER_MENU, 7720 STAY_ON_WHILE_PLUGGED_IN, 7721 AUTO_TIME, 7722 AUTO_TIME_ZONE, 7723 POWER_SOUNDS_ENABLED, 7724 DOCK_SOUNDS_ENABLED, 7725 USB_MASS_STORAGE_ENABLED, 7726 ENABLE_ACCESSIBILITY_GLOBAL_GESTURE_ENABLED, 7727 WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON, 7728 WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY, 7729 WIFI_WATCHDOG_POOR_NETWORK_TEST_ENABLED, 7730 WIFI_NUM_OPEN_NETWORKS_KEPT, 7731 EMERGENCY_TONE, 7732 CALL_AUTO_RETRY, 7733 DOCK_AUDIO_MEDIA_ENABLED, 7734 LOW_POWER_MODE_TRIGGER_LEVEL 7735 }; 7736 7737 // Populated lazily, guarded by class object: 7738 private static NameValueCache sNameValueCache = new NameValueCache( 7739 SYS_PROP_SETTING_VERSION, 7740 CONTENT_URI, 7741 CALL_METHOD_GET_GLOBAL, 7742 CALL_METHOD_PUT_GLOBAL); 7743 7744 // Certain settings have been moved from global to the per-user secure namespace 7745 private static final HashSet<String> MOVED_TO_SECURE; 7746 static { 7747 MOVED_TO_SECURE = new HashSet<String>(1); 7748 MOVED_TO_SECURE.add(Settings.Global.INSTALL_NON_MARKET_APPS); 7749 } 7750 7751 /** @hide */ getMovedToSecureSettings(Set<String> outKeySet)7752 public static void getMovedToSecureSettings(Set<String> outKeySet) { 7753 outKeySet.addAll(MOVED_TO_SECURE); 7754 } 7755 7756 /** 7757 * Look up a name in the database. 7758 * @param resolver to access the database with 7759 * @param name to look up in the table 7760 * @return the corresponding value, or null if not present 7761 */ getString(ContentResolver resolver, String name)7762 public static String getString(ContentResolver resolver, String name) { 7763 return getStringForUser(resolver, name, UserHandle.myUserId()); 7764 } 7765 7766 /** @hide */ getStringForUser(ContentResolver resolver, String name, int userHandle)7767 public static String getStringForUser(ContentResolver resolver, String name, 7768 int userHandle) { 7769 if (MOVED_TO_SECURE.contains(name)) { 7770 Log.w(TAG, "Setting " + name + " has moved from android.provider.Settings.Global" 7771 + " to android.provider.Settings.Secure, returning read-only value."); 7772 return Secure.getStringForUser(resolver, name, userHandle); 7773 } 7774 return sNameValueCache.getStringForUser(resolver, name, userHandle); 7775 } 7776 7777 /** 7778 * Store a name/value pair into the database. 7779 * @param resolver to access the database with 7780 * @param name to store 7781 * @param value to associate with the name 7782 * @return true if the value was set, false on database errors 7783 */ putString(ContentResolver resolver, String name, String value)7784 public static boolean putString(ContentResolver resolver, 7785 String name, String value) { 7786 return putStringForUser(resolver, name, value, UserHandle.myUserId()); 7787 } 7788 7789 /** @hide */ putStringForUser(ContentResolver resolver, String name, String value, int userHandle)7790 public static boolean putStringForUser(ContentResolver resolver, 7791 String name, String value, int userHandle) { 7792 if (LOCAL_LOGV) { 7793 Log.v(TAG, "Global.putString(name=" + name + ", value=" + value 7794 + " for " + userHandle); 7795 } 7796 // Global and Secure have the same access policy so we can forward writes 7797 if (MOVED_TO_SECURE.contains(name)) { 7798 Log.w(TAG, "Setting " + name + " has moved from android.provider.Settings.Global" 7799 + " to android.provider.Settings.Secure, value is unchanged."); 7800 return Secure.putStringForUser(resolver, name, value, userHandle); 7801 } 7802 return sNameValueCache.putStringForUser(resolver, name, value, userHandle); 7803 } 7804 7805 /** 7806 * Construct the content URI for a particular name/value pair, 7807 * useful for monitoring changes with a ContentObserver. 7808 * @param name to look up in the table 7809 * @return the corresponding content URI, or null if not present 7810 */ getUriFor(String name)7811 public static Uri getUriFor(String name) { 7812 return getUriFor(CONTENT_URI, name); 7813 } 7814 7815 /** 7816 * Convenience function for retrieving a single secure settings value 7817 * as an integer. Note that internally setting values are always 7818 * stored as strings; this function converts the string to an integer 7819 * for you. The default value will be returned if the setting is 7820 * not defined or not an integer. 7821 * 7822 * @param cr The ContentResolver to access. 7823 * @param name The name of the setting to retrieve. 7824 * @param def Value to return if the setting is not defined. 7825 * 7826 * @return The setting's current value, or 'def' if it is not defined 7827 * or not a valid integer. 7828 */ getInt(ContentResolver cr, String name, int def)7829 public static int getInt(ContentResolver cr, String name, int def) { 7830 String v = getString(cr, name); 7831 try { 7832 return v != null ? Integer.parseInt(v) : def; 7833 } catch (NumberFormatException e) { 7834 return def; 7835 } 7836 } 7837 7838 /** 7839 * Convenience function for retrieving a single secure settings value 7840 * as an integer. Note that internally setting values are always 7841 * stored as strings; this function converts the string to an integer 7842 * for you. 7843 * <p> 7844 * This version does not take a default value. If the setting has not 7845 * been set, or the string value is not a number, 7846 * it throws {@link SettingNotFoundException}. 7847 * 7848 * @param cr The ContentResolver to access. 7849 * @param name The name of the setting to retrieve. 7850 * 7851 * @throws SettingNotFoundException Thrown if a setting by the given 7852 * name can't be found or the setting value is not an integer. 7853 * 7854 * @return The setting's current value. 7855 */ getInt(ContentResolver cr, String name)7856 public static int getInt(ContentResolver cr, String name) 7857 throws SettingNotFoundException { 7858 String v = getString(cr, name); 7859 try { 7860 return Integer.parseInt(v); 7861 } catch (NumberFormatException e) { 7862 throw new SettingNotFoundException(name); 7863 } 7864 } 7865 7866 /** 7867 * Convenience function for updating a single settings value as an 7868 * integer. This will either create a new entry in the table if the 7869 * given name does not exist, or modify the value of the existing row 7870 * with that name. Note that internally setting values are always 7871 * stored as strings, so this function converts the given value to a 7872 * string before storing it. 7873 * 7874 * @param cr The ContentResolver to access. 7875 * @param name The name of the setting to modify. 7876 * @param value The new value for the setting. 7877 * @return true if the value was set, false on database errors 7878 */ putInt(ContentResolver cr, String name, int value)7879 public static boolean putInt(ContentResolver cr, String name, int value) { 7880 return putString(cr, name, Integer.toString(value)); 7881 } 7882 7883 /** 7884 * Convenience function for retrieving a single secure settings value 7885 * as a {@code long}. Note that internally setting values are always 7886 * stored as strings; this function converts the string to a {@code long} 7887 * for you. The default value will be returned if the setting is 7888 * not defined or not a {@code long}. 7889 * 7890 * @param cr The ContentResolver to access. 7891 * @param name The name of the setting to retrieve. 7892 * @param def Value to return if the setting is not defined. 7893 * 7894 * @return The setting's current value, or 'def' if it is not defined 7895 * or not a valid {@code long}. 7896 */ getLong(ContentResolver cr, String name, long def)7897 public static long getLong(ContentResolver cr, String name, long def) { 7898 String valString = getString(cr, name); 7899 long value; 7900 try { 7901 value = valString != null ? Long.parseLong(valString) : def; 7902 } catch (NumberFormatException e) { 7903 value = def; 7904 } 7905 return value; 7906 } 7907 7908 /** 7909 * Convenience function for retrieving a single secure settings value 7910 * as a {@code long}. Note that internally setting values are always 7911 * stored as strings; this function converts the string to a {@code long} 7912 * for you. 7913 * <p> 7914 * This version does not take a default value. If the setting has not 7915 * been set, or the string value is not a number, 7916 * it throws {@link SettingNotFoundException}. 7917 * 7918 * @param cr The ContentResolver to access. 7919 * @param name The name of the setting to retrieve. 7920 * 7921 * @return The setting's current value. 7922 * @throws SettingNotFoundException Thrown if a setting by the given 7923 * name can't be found or the setting value is not an integer. 7924 */ getLong(ContentResolver cr, String name)7925 public static long getLong(ContentResolver cr, String name) 7926 throws SettingNotFoundException { 7927 String valString = getString(cr, name); 7928 try { 7929 return Long.parseLong(valString); 7930 } catch (NumberFormatException e) { 7931 throw new SettingNotFoundException(name); 7932 } 7933 } 7934 7935 /** 7936 * Convenience function for updating a secure settings value as a long 7937 * integer. This will either create a new entry in the table if the 7938 * given name does not exist, or modify the value of the existing row 7939 * with that name. Note that internally setting values are always 7940 * stored as strings, so this function converts the given value to a 7941 * string before storing it. 7942 * 7943 * @param cr The ContentResolver to access. 7944 * @param name The name of the setting to modify. 7945 * @param value The new value for the setting. 7946 * @return true if the value was set, false on database errors 7947 */ putLong(ContentResolver cr, String name, long value)7948 public static boolean putLong(ContentResolver cr, String name, long value) { 7949 return putString(cr, name, Long.toString(value)); 7950 } 7951 7952 /** 7953 * Convenience function for retrieving a single secure settings value 7954 * as a floating point number. Note that internally setting values are 7955 * always stored as strings; this function converts the string to an 7956 * float for you. The default value will be returned if the setting 7957 * is not defined or not a valid float. 7958 * 7959 * @param cr The ContentResolver to access. 7960 * @param name The name of the setting to retrieve. 7961 * @param def Value to return if the setting is not defined. 7962 * 7963 * @return The setting's current value, or 'def' if it is not defined 7964 * or not a valid float. 7965 */ getFloat(ContentResolver cr, String name, float def)7966 public static float getFloat(ContentResolver cr, String name, float def) { 7967 String v = getString(cr, name); 7968 try { 7969 return v != null ? Float.parseFloat(v) : def; 7970 } catch (NumberFormatException e) { 7971 return def; 7972 } 7973 } 7974 7975 /** 7976 * Convenience function for retrieving a single secure settings value 7977 * as a float. Note that internally setting values are always 7978 * stored as strings; this function converts the string to a float 7979 * for you. 7980 * <p> 7981 * This version does not take a default value. If the setting has not 7982 * been set, or the string value is not a number, 7983 * it throws {@link SettingNotFoundException}. 7984 * 7985 * @param cr The ContentResolver to access. 7986 * @param name The name of the setting to retrieve. 7987 * 7988 * @throws SettingNotFoundException Thrown if a setting by the given 7989 * name can't be found or the setting value is not a float. 7990 * 7991 * @return The setting's current value. 7992 */ getFloat(ContentResolver cr, String name)7993 public static float getFloat(ContentResolver cr, String name) 7994 throws SettingNotFoundException { 7995 String v = getString(cr, name); 7996 if (v == null) { 7997 throw new SettingNotFoundException(name); 7998 } 7999 try { 8000 return Float.parseFloat(v); 8001 } catch (NumberFormatException e) { 8002 throw new SettingNotFoundException(name); 8003 } 8004 } 8005 8006 /** 8007 * Convenience function for updating a single settings value as a 8008 * floating point number. This will either create a new entry in the 8009 * table if the given name does not exist, or modify the value of the 8010 * existing row with that name. Note that internally setting values 8011 * are always stored as strings, so this function converts the given 8012 * value to a string before storing it. 8013 * 8014 * @param cr The ContentResolver to access. 8015 * @param name The name of the setting to modify. 8016 * @param value The new value for the setting. 8017 * @return true if the value was set, false on database errors 8018 */ putFloat(ContentResolver cr, String name, float value)8019 public static boolean putFloat(ContentResolver cr, String name, float value) { 8020 return putString(cr, name, Float.toString(value)); 8021 } 8022 8023 8024 /** 8025 * Subscription to be used for voice call on a multi sim device. The supported values 8026 * are 0 = SUB1, 1 = SUB2 and etc. 8027 * @hide 8028 */ 8029 public static final String MULTI_SIM_VOICE_CALL_SUBSCRIPTION = "multi_sim_voice_call"; 8030 8031 /** 8032 * Used to provide option to user to select subscription during dial. 8033 * The supported values are 0 = disable or 1 = enable prompt. 8034 * @hide 8035 */ 8036 public static final String MULTI_SIM_VOICE_PROMPT = "multi_sim_voice_prompt"; 8037 8038 /** 8039 * Subscription to be used for data call on a multi sim device. The supported values 8040 * are 0 = SUB1, 1 = SUB2 and etc. 8041 * @hide 8042 */ 8043 public static final String MULTI_SIM_DATA_CALL_SUBSCRIPTION = "multi_sim_data_call"; 8044 8045 /** 8046 * Subscription to be used for SMS on a multi sim device. The supported values 8047 * are 0 = SUB1, 1 = SUB2 and etc. 8048 * @hide 8049 */ 8050 public static final String MULTI_SIM_SMS_SUBSCRIPTION = "multi_sim_sms"; 8051 8052 /** 8053 * Used to provide option to user to select subscription during send SMS. 8054 * The value 1 - enable, 0 - disable 8055 * @hide 8056 */ 8057 public static final String MULTI_SIM_SMS_PROMPT = "multi_sim_sms_prompt"; 8058 8059 8060 8061 /** User preferred subscriptions setting. 8062 * This holds the details of the user selected subscription from the card and 8063 * the activation status. Each settings string have the coma separated values 8064 * iccId,appType,appId,activationStatus,3gppIndex,3gpp2Index 8065 * @hide 8066 */ 8067 public static final String[] MULTI_SIM_USER_PREFERRED_SUBS = {"user_preferred_sub1", 8068 "user_preferred_sub2","user_preferred_sub3"}; 8069 8070 /** 8071 * Whether to enable new contacts aggregator or not. 8072 * The value 1 - enable, 0 - disable 8073 * @hide 8074 */ 8075 public static final String NEW_CONTACT_AGGREGATOR = "new_contact_aggregator"; 8076 8077 /** 8078 * Whether to enable contacts metadata syncing or not 8079 * The value 1 - enable, 0 - disable 8080 * @hide 8081 */ 8082 public static final String CONTACT_METADATA_SYNC = "contact_metadata_sync"; 8083 } 8084 8085 /** 8086 * User-defined bookmarks and shortcuts. The target of each bookmark is an 8087 * Intent URL, allowing it to be either a web page or a particular 8088 * application activity. 8089 * 8090 * @hide 8091 */ 8092 public static final class Bookmarks implements BaseColumns 8093 { 8094 private static final String TAG = "Bookmarks"; 8095 8096 /** 8097 * The content:// style URL for this table 8098 */ 8099 public static final Uri CONTENT_URI = 8100 Uri.parse("content://" + AUTHORITY + "/bookmarks"); 8101 8102 /** 8103 * The row ID. 8104 * <p>Type: INTEGER</p> 8105 */ 8106 public static final String ID = "_id"; 8107 8108 /** 8109 * Descriptive name of the bookmark that can be displayed to the user. 8110 * If this is empty, the title should be resolved at display time (use 8111 * {@link #getTitle(Context, Cursor)} any time you want to display the 8112 * title of a bookmark.) 8113 * <P> 8114 * Type: TEXT 8115 * </P> 8116 */ 8117 public static final String TITLE = "title"; 8118 8119 /** 8120 * Arbitrary string (displayed to the user) that allows bookmarks to be 8121 * organized into categories. There are some special names for 8122 * standard folders, which all start with '@'. The label displayed for 8123 * the folder changes with the locale (via {@link #getLabelForFolder}) but 8124 * the folder name does not change so you can consistently query for 8125 * the folder regardless of the current locale. 8126 * 8127 * <P>Type: TEXT</P> 8128 * 8129 */ 8130 public static final String FOLDER = "folder"; 8131 8132 /** 8133 * The Intent URL of the bookmark, describing what it points to. This 8134 * value is given to {@link android.content.Intent#getIntent} to create 8135 * an Intent that can be launched. 8136 * <P>Type: TEXT</P> 8137 */ 8138 public static final String INTENT = "intent"; 8139 8140 /** 8141 * Optional shortcut character associated with this bookmark. 8142 * <P>Type: INTEGER</P> 8143 */ 8144 public static final String SHORTCUT = "shortcut"; 8145 8146 /** 8147 * The order in which the bookmark should be displayed 8148 * <P>Type: INTEGER</P> 8149 */ 8150 public static final String ORDERING = "ordering"; 8151 8152 private static final String[] sIntentProjection = { INTENT }; 8153 private static final String[] sShortcutProjection = { ID, SHORTCUT }; 8154 private static final String sShortcutSelection = SHORTCUT + "=?"; 8155 8156 /** 8157 * Convenience function to retrieve the bookmarked Intent for a 8158 * particular shortcut key. 8159 * 8160 * @param cr The ContentResolver to query. 8161 * @param shortcut The shortcut key. 8162 * 8163 * @return Intent The bookmarked URL, or null if there is no bookmark 8164 * matching the given shortcut. 8165 */ getIntentForShortcut(ContentResolver cr, char shortcut)8166 public static Intent getIntentForShortcut(ContentResolver cr, char shortcut) 8167 { 8168 Intent intent = null; 8169 8170 Cursor c = cr.query(CONTENT_URI, 8171 sIntentProjection, sShortcutSelection, 8172 new String[] { String.valueOf((int) shortcut) }, ORDERING); 8173 // Keep trying until we find a valid shortcut 8174 try { 8175 while (intent == null && c.moveToNext()) { 8176 try { 8177 String intentURI = c.getString(c.getColumnIndexOrThrow(INTENT)); 8178 intent = Intent.parseUri(intentURI, 0); 8179 } catch (java.net.URISyntaxException e) { 8180 // The stored URL is bad... ignore it. 8181 } catch (IllegalArgumentException e) { 8182 // Column not found 8183 Log.w(TAG, "Intent column not found", e); 8184 } 8185 } 8186 } finally { 8187 if (c != null) c.close(); 8188 } 8189 8190 return intent; 8191 } 8192 8193 /** 8194 * Add a new bookmark to the system. 8195 * 8196 * @param cr The ContentResolver to query. 8197 * @param intent The desired target of the bookmark. 8198 * @param title Bookmark title that is shown to the user; null if none 8199 * or it should be resolved to the intent's title. 8200 * @param folder Folder in which to place the bookmark; null if none. 8201 * @param shortcut Shortcut that will invoke the bookmark; 0 if none. If 8202 * this is non-zero and there is an existing bookmark entry 8203 * with this same shortcut, then that existing shortcut is 8204 * cleared (the bookmark is not removed). 8205 * @return The unique content URL for the new bookmark entry. 8206 */ add(ContentResolver cr, Intent intent, String title, String folder, char shortcut, int ordering)8207 public static Uri add(ContentResolver cr, 8208 Intent intent, 8209 String title, 8210 String folder, 8211 char shortcut, 8212 int ordering) 8213 { 8214 // If a shortcut is supplied, and it is already defined for 8215 // another bookmark, then remove the old definition. 8216 if (shortcut != 0) { 8217 cr.delete(CONTENT_URI, sShortcutSelection, 8218 new String[] { String.valueOf((int) shortcut) }); 8219 } 8220 8221 ContentValues values = new ContentValues(); 8222 if (title != null) values.put(TITLE, title); 8223 if (folder != null) values.put(FOLDER, folder); 8224 values.put(INTENT, intent.toUri(0)); 8225 if (shortcut != 0) values.put(SHORTCUT, (int) shortcut); 8226 values.put(ORDERING, ordering); 8227 return cr.insert(CONTENT_URI, values); 8228 } 8229 8230 /** 8231 * Return the folder name as it should be displayed to the user. This 8232 * takes care of localizing special folders. 8233 * 8234 * @param r Resources object for current locale; only need access to 8235 * system resources. 8236 * @param folder The value found in the {@link #FOLDER} column. 8237 * 8238 * @return CharSequence The label for this folder that should be shown 8239 * to the user. 8240 */ getLabelForFolder(Resources r, String folder)8241 public static CharSequence getLabelForFolder(Resources r, String folder) { 8242 return folder; 8243 } 8244 8245 /** 8246 * Return the title as it should be displayed to the user. This takes 8247 * care of localizing bookmarks that point to activities. 8248 * 8249 * @param context A context. 8250 * @param cursor A cursor pointing to the row whose title should be 8251 * returned. The cursor must contain at least the {@link #TITLE} 8252 * and {@link #INTENT} columns. 8253 * @return A title that is localized and can be displayed to the user, 8254 * or the empty string if one could not be found. 8255 */ getTitle(Context context, Cursor cursor)8256 public static CharSequence getTitle(Context context, Cursor cursor) { 8257 int titleColumn = cursor.getColumnIndex(TITLE); 8258 int intentColumn = cursor.getColumnIndex(INTENT); 8259 if (titleColumn == -1 || intentColumn == -1) { 8260 throw new IllegalArgumentException( 8261 "The cursor must contain the TITLE and INTENT columns."); 8262 } 8263 8264 String title = cursor.getString(titleColumn); 8265 if (!TextUtils.isEmpty(title)) { 8266 return title; 8267 } 8268 8269 String intentUri = cursor.getString(intentColumn); 8270 if (TextUtils.isEmpty(intentUri)) { 8271 return ""; 8272 } 8273 8274 Intent intent; 8275 try { 8276 intent = Intent.parseUri(intentUri, 0); 8277 } catch (URISyntaxException e) { 8278 return ""; 8279 } 8280 8281 PackageManager packageManager = context.getPackageManager(); 8282 ResolveInfo info = packageManager.resolveActivity(intent, 0); 8283 return info != null ? info.loadLabel(packageManager) : ""; 8284 } 8285 } 8286 8287 /** 8288 * Returns the device ID that we should use when connecting to the mobile gtalk server. 8289 * This is a string like "android-0x1242", where the hex string is the Android ID obtained 8290 * from the GoogleLoginService. 8291 * 8292 * @param androidId The Android ID for this device. 8293 * @return The device ID that should be used when connecting to the mobile gtalk server. 8294 * @hide 8295 */ getGTalkDeviceId(long androidId)8296 public static String getGTalkDeviceId(long androidId) { 8297 return "android-" + Long.toHexString(androidId); 8298 } 8299 8300 private static final String[] PM_WRITE_SETTINGS = { 8301 android.Manifest.permission.WRITE_SETTINGS 8302 }; 8303 private static final String[] PM_CHANGE_NETWORK_STATE = { 8304 android.Manifest.permission.CHANGE_NETWORK_STATE, 8305 android.Manifest.permission.WRITE_SETTINGS 8306 }; 8307 private static final String[] PM_SYSTEM_ALERT_WINDOW = { 8308 android.Manifest.permission.SYSTEM_ALERT_WINDOW 8309 }; 8310 8311 /** 8312 * Performs a strict and comprehensive check of whether a calling package is allowed to 8313 * write/modify system settings, as the condition differs for pre-M, M+, and 8314 * privileged/preinstalled apps. If the provided uid does not match the 8315 * callingPackage, a negative result will be returned. 8316 * @hide 8317 */ isCallingPackageAllowedToWriteSettings(Context context, int uid, String callingPackage, boolean throwException)8318 public static boolean isCallingPackageAllowedToWriteSettings(Context context, int uid, 8319 String callingPackage, boolean throwException) { 8320 return isCallingPackageAllowedToPerformAppOpsProtectedOperation(context, uid, 8321 callingPackage, throwException, AppOpsManager.OP_WRITE_SETTINGS, 8322 PM_WRITE_SETTINGS, false); 8323 } 8324 8325 /** 8326 * Performs a strict and comprehensive check of whether a calling package is allowed to 8327 * write/modify system settings, as the condition differs for pre-M, M+, and 8328 * privileged/preinstalled apps. If the provided uid does not match the 8329 * callingPackage, a negative result will be returned. The caller is expected to have 8330 * either WRITE_SETTINGS or CHANGE_NETWORK_STATE permission declared. 8331 * 8332 * Note: if the check is successful, the operation of this app will be updated to the 8333 * current time. 8334 * @hide 8335 */ checkAndNoteWriteSettingsOperation(Context context, int uid, String callingPackage, boolean throwException)8336 public static boolean checkAndNoteWriteSettingsOperation(Context context, int uid, 8337 String callingPackage, boolean throwException) { 8338 return isCallingPackageAllowedToPerformAppOpsProtectedOperation(context, uid, 8339 callingPackage, throwException, AppOpsManager.OP_WRITE_SETTINGS, 8340 PM_WRITE_SETTINGS, true); 8341 } 8342 8343 /** 8344 * Performs a strict and comprehensive check of whether a calling package is allowed to 8345 * change the state of network, as the condition differs for pre-M, M+, and 8346 * privileged/preinstalled apps. If the provided uid does not match the 8347 * callingPackage, a negative result will be returned. The caller is expected to have 8348 * either of CHANGE_NETWORK_STATE or WRITE_SETTINGS permission declared. 8349 * @hide 8350 */ isCallingPackageAllowedToChangeNetworkState(Context context, int uid, String callingPackage, boolean throwException)8351 public static boolean isCallingPackageAllowedToChangeNetworkState(Context context, int uid, 8352 String callingPackage, boolean throwException) { 8353 return isCallingPackageAllowedToPerformAppOpsProtectedOperation(context, uid, 8354 callingPackage, throwException, AppOpsManager.OP_WRITE_SETTINGS, 8355 PM_CHANGE_NETWORK_STATE, false); 8356 } 8357 8358 /** 8359 * Performs a strict and comprehensive check of whether a calling package is allowed to 8360 * change the state of network, as the condition differs for pre-M, M+, and 8361 * privileged/preinstalled apps. If the provided uid does not match the 8362 * callingPackage, a negative result will be returned. The caller is expected to have 8363 * either CHANGE_NETWORK_STATE or WRITE_SETTINGS permission declared. 8364 * 8365 * Note: if the check is successful, the operation of this app will be updated to the 8366 * current time. 8367 * @hide 8368 */ checkAndNoteChangeNetworkStateOperation(Context context, int uid, String callingPackage, boolean throwException)8369 public static boolean checkAndNoteChangeNetworkStateOperation(Context context, int uid, 8370 String callingPackage, boolean throwException) { 8371 return isCallingPackageAllowedToPerformAppOpsProtectedOperation(context, uid, 8372 callingPackage, throwException, AppOpsManager.OP_WRITE_SETTINGS, 8373 PM_CHANGE_NETWORK_STATE, true); 8374 } 8375 8376 /** 8377 * Performs a strict and comprehensive check of whether a calling package is allowed to 8378 * draw on top of other apps, as the conditions differs for pre-M, M+, and 8379 * privileged/preinstalled apps. If the provided uid does not match the callingPackage, 8380 * a negative result will be returned. 8381 * @hide 8382 */ isCallingPackageAllowedToDrawOverlays(Context context, int uid, String callingPackage, boolean throwException)8383 public static boolean isCallingPackageAllowedToDrawOverlays(Context context, int uid, 8384 String callingPackage, boolean throwException) { 8385 return isCallingPackageAllowedToPerformAppOpsProtectedOperation(context, uid, 8386 callingPackage, throwException, AppOpsManager.OP_SYSTEM_ALERT_WINDOW, 8387 PM_SYSTEM_ALERT_WINDOW, false); 8388 } 8389 8390 /** 8391 * Performs a strict and comprehensive check of whether a calling package is allowed to 8392 * draw on top of other apps, as the conditions differs for pre-M, M+, and 8393 * privileged/preinstalled apps. If the provided uid does not match the callingPackage, 8394 * a negative result will be returned. 8395 * 8396 * Note: if the check is successful, the operation of this app will be updated to the 8397 * current time. 8398 * @hide 8399 */ checkAndNoteDrawOverlaysOperation(Context context, int uid, String callingPackage, boolean throwException)8400 public static boolean checkAndNoteDrawOverlaysOperation(Context context, int uid, String 8401 callingPackage, boolean throwException) { 8402 return isCallingPackageAllowedToPerformAppOpsProtectedOperation(context, uid, 8403 callingPackage, throwException, AppOpsManager.OP_SYSTEM_ALERT_WINDOW, 8404 PM_SYSTEM_ALERT_WINDOW, true); 8405 } 8406 8407 /** 8408 * Helper method to perform a general and comprehensive check of whether an operation that is 8409 * protected by appops can be performed by a caller or not. e.g. OP_SYSTEM_ALERT_WINDOW and 8410 * OP_WRITE_SETTINGS 8411 * @hide 8412 */ isCallingPackageAllowedToPerformAppOpsProtectedOperation(Context context, int uid, String callingPackage, boolean throwException, int appOpsOpCode, String[] permissions, boolean makeNote)8413 public static boolean isCallingPackageAllowedToPerformAppOpsProtectedOperation(Context context, 8414 int uid, String callingPackage, boolean throwException, int appOpsOpCode, String[] 8415 permissions, boolean makeNote) { 8416 if (callingPackage == null) { 8417 return false; 8418 } 8419 8420 AppOpsManager appOpsMgr = (AppOpsManager)context.getSystemService(Context.APP_OPS_SERVICE); 8421 int mode = AppOpsManager.MODE_DEFAULT; 8422 if (makeNote) { 8423 mode = appOpsMgr.noteOpNoThrow(appOpsOpCode, uid, callingPackage); 8424 } else { 8425 mode = appOpsMgr.checkOpNoThrow(appOpsOpCode, uid, callingPackage); 8426 } 8427 8428 switch (mode) { 8429 case AppOpsManager.MODE_ALLOWED: 8430 return true; 8431 8432 case AppOpsManager.MODE_DEFAULT: 8433 // this is the default operating mode after an app's installation 8434 // In this case we will check all associated static permission to see 8435 // if it is granted during install time. 8436 for (String permission : permissions) { 8437 if (context.checkCallingOrSelfPermission(permission) == PackageManager 8438 .PERMISSION_GRANTED) { 8439 // if either of the permissions are granted, we will allow it 8440 return true; 8441 } 8442 } 8443 8444 default: 8445 // this is for all other cases trickled down here... 8446 if (!throwException) { 8447 return false; 8448 } 8449 } 8450 8451 // prepare string to throw SecurityException 8452 StringBuilder exceptionMessage = new StringBuilder(); 8453 exceptionMessage.append(callingPackage); 8454 exceptionMessage.append(" was not granted "); 8455 if (permissions.length > 1) { 8456 exceptionMessage.append(" either of these permissions: "); 8457 } else { 8458 exceptionMessage.append(" this permission: "); 8459 } 8460 for (int i = 0; i < permissions.length; i++) { 8461 exceptionMessage.append(permissions[i]); 8462 exceptionMessage.append((i == permissions.length - 1) ? "." : ", "); 8463 } 8464 8465 throw new SecurityException(exceptionMessage.toString()); 8466 } 8467 8468 /** 8469 * Retrieves a correponding package name for a given uid. It will query all 8470 * packages that are associated with the given uid, but it will return only 8471 * the zeroth result. 8472 * Note: If package could not be found, a null is returned. 8473 * @hide 8474 */ getPackageNameForUid(Context context, int uid)8475 public static String getPackageNameForUid(Context context, int uid) { 8476 String[] packages = context.getPackageManager().getPackagesForUid(uid); 8477 if (packages == null) { 8478 return null; 8479 } 8480 return packages[0]; 8481 } 8482 } 8483