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.app.SearchManager; 22 import android.app.WallpaperManager; 23 import android.content.ComponentName; 24 import android.content.ContentResolver; 25 import android.content.ContentValues; 26 import android.content.Context; 27 import android.content.IContentProvider; 28 import android.content.Intent; 29 import android.content.pm.ActivityInfo; 30 import android.content.pm.PackageManager; 31 import android.content.pm.ResolveInfo; 32 import android.content.res.Configuration; 33 import android.content.res.Resources; 34 import android.database.Cursor; 35 import android.database.SQLException; 36 import android.location.LocationManager; 37 import android.net.ConnectivityManager; 38 import android.net.Uri; 39 import android.net.wifi.WifiManager; 40 import android.os.BatteryManager; 41 import android.os.Bundle; 42 import android.os.DropBoxManager; 43 import android.os.IBinder; 44 import android.os.Process; 45 import android.os.RemoteException; 46 import android.os.ServiceManager; 47 import android.os.SystemProperties; 48 import android.os.UserHandle; 49 import android.os.Build.VERSION_CODES; 50 import android.speech.tts.TextToSpeech; 51 import android.text.TextUtils; 52 import android.util.AndroidException; 53 import android.util.Log; 54 55 import com.android.internal.widget.ILockSettings; 56 57 import java.net.URISyntaxException; 58 import java.util.HashMap; 59 import java.util.HashSet; 60 import java.util.Locale; 61 62 /** 63 * The Settings provider contains global system-level device preferences. 64 */ 65 public final class Settings { 66 67 // Intent actions for Settings 68 69 /** 70 * Activity Action: Show system settings. 71 * <p> 72 * Input: Nothing. 73 * <p> 74 * Output: Nothing. 75 */ 76 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 77 public static final String ACTION_SETTINGS = "android.settings.SETTINGS"; 78 79 /** 80 * Activity Action: Show settings to allow configuration of APNs. 81 * <p> 82 * Input: Nothing. 83 * <p> 84 * Output: Nothing. 85 */ 86 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 87 public static final String ACTION_APN_SETTINGS = "android.settings.APN_SETTINGS"; 88 89 /** 90 * Activity Action: Show settings to allow configuration of current location 91 * sources. 92 * <p> 93 * In some cases, a matching Activity may not exist, so ensure you 94 * safeguard against this. 95 * <p> 96 * Input: Nothing. 97 * <p> 98 * Output: Nothing. 99 */ 100 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 101 public static final String ACTION_LOCATION_SOURCE_SETTINGS = 102 "android.settings.LOCATION_SOURCE_SETTINGS"; 103 104 /** 105 * Activity Action: Show settings to allow configuration of wireless controls 106 * such as Wi-Fi, Bluetooth and Mobile networks. 107 * <p> 108 * In some cases, a matching Activity may not exist, so ensure you 109 * safeguard against this. 110 * <p> 111 * Input: Nothing. 112 * <p> 113 * Output: Nothing. 114 */ 115 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 116 public static final String ACTION_WIRELESS_SETTINGS = 117 "android.settings.WIRELESS_SETTINGS"; 118 119 /** 120 * Activity Action: Show settings to allow entering/exiting airplane mode. 121 * <p> 122 * In some cases, a matching Activity may not exist, so ensure you 123 * safeguard against this. 124 * <p> 125 * Input: Nothing. 126 * <p> 127 * Output: Nothing. 128 */ 129 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 130 public static final String ACTION_AIRPLANE_MODE_SETTINGS = 131 "android.settings.AIRPLANE_MODE_SETTINGS"; 132 133 /** 134 * Activity Action: Show settings for accessibility modules. 135 * <p> 136 * In some cases, a matching Activity may not exist, so ensure you 137 * safeguard against this. 138 * <p> 139 * Input: Nothing. 140 * <p> 141 * Output: Nothing. 142 */ 143 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 144 public static final String ACTION_ACCESSIBILITY_SETTINGS = 145 "android.settings.ACCESSIBILITY_SETTINGS"; 146 147 /** 148 * Activity Action: Show settings to allow configuration of security and 149 * location privacy. 150 * <p> 151 * In some cases, a matching Activity may not exist, so ensure you 152 * safeguard against this. 153 * <p> 154 * Input: Nothing. 155 * <p> 156 * Output: Nothing. 157 */ 158 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 159 public static final String ACTION_SECURITY_SETTINGS = 160 "android.settings.SECURITY_SETTINGS"; 161 162 /** 163 * Activity Action: Show trusted credentials settings, opening to the user tab, 164 * to allow management of installed credentials. 165 * <p> 166 * In some cases, a matching Activity may not exist, so ensure you 167 * safeguard against this. 168 * <p> 169 * Input: Nothing. 170 * <p> 171 * Output: Nothing. 172 * @hide 173 */ 174 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 175 public static final String ACTION_TRUSTED_CREDENTIALS_USER = 176 "com.android.settings.TRUSTED_CREDENTIALS_USER"; 177 178 /** 179 * Activity Action: Show dialog explaining that an installed CA cert may enable 180 * monitoring of encrypted network traffic. 181 * <p> 182 * In some cases, a matching Activity may not exist, so ensure you 183 * safeguard against this. 184 * <p> 185 * Input: Nothing. 186 * <p> 187 * Output: Nothing. 188 * @hide 189 */ 190 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 191 public static final String ACTION_MONITORING_CERT_INFO = 192 "com.android.settings.MONITORING_CERT_INFO"; 193 194 /** 195 * Activity Action: Show settings to allow configuration of privacy options. 196 * <p> 197 * In some cases, a matching Activity may not exist, so ensure you 198 * safeguard against this. 199 * <p> 200 * Input: Nothing. 201 * <p> 202 * Output: Nothing. 203 */ 204 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 205 public static final String ACTION_PRIVACY_SETTINGS = 206 "android.settings.PRIVACY_SETTINGS"; 207 208 /** 209 * Activity Action: Show settings to allow configuration of Wi-Fi. 210 211 * <p> 212 * In some cases, a matching Activity may not exist, so ensure you 213 * safeguard against this. 214 * <p> 215 * Input: Nothing. 216 * <p> 217 * Output: Nothing. 218 219 */ 220 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 221 public static final String ACTION_WIFI_SETTINGS = 222 "android.settings.WIFI_SETTINGS"; 223 224 /** 225 * Activity Action: Show settings to allow configuration of a static IP 226 * address for Wi-Fi. 227 * <p> 228 * In some cases, a matching Activity may not exist, so ensure you safeguard 229 * against this. 230 * <p> 231 * Input: Nothing. 232 * <p> 233 * Output: Nothing. 234 */ 235 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 236 public static final String ACTION_WIFI_IP_SETTINGS = 237 "android.settings.WIFI_IP_SETTINGS"; 238 239 /** 240 * Activity Action: Show settings to allow configuration of Bluetooth. 241 * <p> 242 * In some cases, a matching Activity may not exist, so ensure you 243 * safeguard against this. 244 * <p> 245 * Input: Nothing. 246 * <p> 247 * Output: Nothing. 248 */ 249 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 250 public static final String ACTION_BLUETOOTH_SETTINGS = 251 "android.settings.BLUETOOTH_SETTINGS"; 252 253 /** 254 * Activity Action: Show settings to allow configuration of Wifi Displays. 255 * <p> 256 * In some cases, a matching Activity may not exist, so ensure you 257 * safeguard against this. 258 * <p> 259 * Input: Nothing. 260 * <p> 261 * Output: Nothing. 262 * @hide 263 */ 264 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 265 public static final String ACTION_WIFI_DISPLAY_SETTINGS = 266 "android.settings.WIFI_DISPLAY_SETTINGS"; 267 268 /** 269 * Activity Action: Show settings to allow configuration of date and time. 270 * <p> 271 * In some cases, a matching Activity may not exist, so ensure you 272 * safeguard against this. 273 * <p> 274 * Input: Nothing. 275 * <p> 276 * Output: Nothing. 277 */ 278 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 279 public static final String ACTION_DATE_SETTINGS = 280 "android.settings.DATE_SETTINGS"; 281 282 /** 283 * Activity Action: Show settings to allow configuration of sound and volume. 284 * <p> 285 * In some cases, a matching Activity may not exist, so ensure you 286 * safeguard against this. 287 * <p> 288 * Input: Nothing. 289 * <p> 290 * Output: Nothing. 291 */ 292 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 293 public static final String ACTION_SOUND_SETTINGS = 294 "android.settings.SOUND_SETTINGS"; 295 296 /** 297 * Activity Action: Show settings to allow configuration of display. 298 * <p> 299 * In some cases, a matching Activity may not exist, so ensure you 300 * safeguard against this. 301 * <p> 302 * Input: Nothing. 303 * <p> 304 * Output: Nothing. 305 */ 306 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 307 public static final String ACTION_DISPLAY_SETTINGS = 308 "android.settings.DISPLAY_SETTINGS"; 309 310 /** 311 * Activity Action: Show settings to allow configuration of locale. 312 * <p> 313 * In some cases, a matching Activity may not exist, so ensure you 314 * safeguard against this. 315 * <p> 316 * Input: Nothing. 317 * <p> 318 * Output: Nothing. 319 */ 320 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 321 public static final String ACTION_LOCALE_SETTINGS = 322 "android.settings.LOCALE_SETTINGS"; 323 324 /** 325 * Activity Action: Show settings to configure input methods, in particular 326 * allowing the user to enable input methods. 327 * <p> 328 * In some cases, a matching Activity may not exist, so ensure you 329 * safeguard against this. 330 * <p> 331 * Input: Nothing. 332 * <p> 333 * Output: Nothing. 334 */ 335 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 336 public static final String ACTION_INPUT_METHOD_SETTINGS = 337 "android.settings.INPUT_METHOD_SETTINGS"; 338 339 /** 340 * Activity Action: Show settings to enable/disable input method subtypes. 341 * <p> 342 * In some cases, a matching Activity may not exist, so ensure you 343 * safeguard against this. 344 * <p> 345 * To tell which input method's subtypes are displayed in the settings, add 346 * {@link #EXTRA_INPUT_METHOD_ID} extra to this Intent with the input method id. 347 * If there is no extra in this Intent, subtypes from all installed input methods 348 * will be displayed in the settings. 349 * 350 * @see android.view.inputmethod.InputMethodInfo#getId 351 * <p> 352 * Input: Nothing. 353 * <p> 354 * Output: Nothing. 355 */ 356 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 357 public static final String ACTION_INPUT_METHOD_SUBTYPE_SETTINGS = 358 "android.settings.INPUT_METHOD_SUBTYPE_SETTINGS"; 359 360 /** 361 * Activity Action: Show a dialog to select input method. 362 * <p> 363 * In some cases, a matching Activity may not exist, so ensure you 364 * safeguard against this. 365 * <p> 366 * Input: Nothing. 367 * <p> 368 * Output: Nothing. 369 * @hide 370 */ 371 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 372 public static final String ACTION_SHOW_INPUT_METHOD_PICKER = 373 "android.settings.SHOW_INPUT_METHOD_PICKER"; 374 375 /** 376 * Activity Action: Show settings to manage the user input dictionary. 377 * <p> 378 * Starting with {@link android.os.Build.VERSION_CODES#KITKAT}, 379 * it is guaranteed there will always be an appropriate implementation for this Intent action. 380 * In prior releases of the platform this was optional, so ensure you safeguard against it. 381 * <p> 382 * Input: Nothing. 383 * <p> 384 * Output: Nothing. 385 */ 386 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 387 public static final String ACTION_USER_DICTIONARY_SETTINGS = 388 "android.settings.USER_DICTIONARY_SETTINGS"; 389 390 /** 391 * Activity Action: Adds a word to the user dictionary. 392 * <p> 393 * In some cases, a matching Activity may not exist, so ensure you 394 * safeguard against this. 395 * <p> 396 * Input: An extra with key <code>word</code> that contains the word 397 * that should be added to the dictionary. 398 * <p> 399 * Output: Nothing. 400 * 401 * @hide 402 */ 403 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 404 public static final String ACTION_USER_DICTIONARY_INSERT = 405 "com.android.settings.USER_DICTIONARY_INSERT"; 406 407 /** 408 * Activity Action: Show settings to allow configuration of application-related settings. 409 * <p> 410 * In some cases, a matching Activity may not exist, so ensure you 411 * safeguard against this. 412 * <p> 413 * Input: Nothing. 414 * <p> 415 * Output: Nothing. 416 */ 417 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 418 public static final String ACTION_APPLICATION_SETTINGS = 419 "android.settings.APPLICATION_SETTINGS"; 420 421 /** 422 * Activity Action: Show settings to allow configuration of application 423 * development-related settings. As of 424 * {@link android.os.Build.VERSION_CODES#JELLY_BEAN_MR1} this action is 425 * a required part of the platform. 426 * <p> 427 * Input: Nothing. 428 * <p> 429 * Output: Nothing. 430 */ 431 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 432 public static final String ACTION_APPLICATION_DEVELOPMENT_SETTINGS = 433 "android.settings.APPLICATION_DEVELOPMENT_SETTINGS"; 434 435 /** 436 * Activity Action: Show settings to allow configuration of quick launch shortcuts. 437 * <p> 438 * In some cases, a matching Activity may not exist, so ensure you 439 * safeguard against this. 440 * <p> 441 * Input: Nothing. 442 * <p> 443 * Output: Nothing. 444 */ 445 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 446 public static final String ACTION_QUICK_LAUNCH_SETTINGS = 447 "android.settings.QUICK_LAUNCH_SETTINGS"; 448 449 /** 450 * Activity Action: Show settings to manage installed applications. 451 * <p> 452 * In some cases, a matching Activity may not exist, so ensure you 453 * safeguard against this. 454 * <p> 455 * Input: Nothing. 456 * <p> 457 * Output: Nothing. 458 */ 459 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 460 public static final String ACTION_MANAGE_APPLICATIONS_SETTINGS = 461 "android.settings.MANAGE_APPLICATIONS_SETTINGS"; 462 463 /** 464 * Activity Action: Show settings to manage all applications. 465 * <p> 466 * In some cases, a matching Activity may not exist, so ensure you 467 * safeguard against this. 468 * <p> 469 * Input: Nothing. 470 * <p> 471 * Output: Nothing. 472 */ 473 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 474 public static final String ACTION_MANAGE_ALL_APPLICATIONS_SETTINGS = 475 "android.settings.MANAGE_ALL_APPLICATIONS_SETTINGS"; 476 477 /** 478 * Activity Action: Show screen of details about a particular application. 479 * <p> 480 * In some cases, a matching Activity may not exist, so ensure you 481 * safeguard against this. 482 * <p> 483 * Input: The Intent's data URI specifies the application package name 484 * to be shown, with the "package" scheme. That is "package:com.my.app". 485 * <p> 486 * Output: Nothing. 487 */ 488 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 489 public static final String ACTION_APPLICATION_DETAILS_SETTINGS = 490 "android.settings.APPLICATION_DETAILS_SETTINGS"; 491 492 /** 493 * @hide 494 * Activity Action: Show the "app ops" settings screen. 495 * <p> 496 * Input: Nothing. 497 * <p> 498 * Output: Nothing. 499 */ 500 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 501 public static final String ACTION_APP_OPS_SETTINGS = 502 "android.settings.APP_OPS_SETTINGS"; 503 504 /** 505 * Activity Action: Show settings for system update functionality. 506 * <p> 507 * In some cases, a matching Activity may not exist, so ensure you 508 * safeguard against this. 509 * <p> 510 * Input: Nothing. 511 * <p> 512 * Output: Nothing. 513 * 514 * @hide 515 */ 516 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 517 public static final String ACTION_SYSTEM_UPDATE_SETTINGS = 518 "android.settings.SYSTEM_UPDATE_SETTINGS"; 519 520 /** 521 * Activity Action: Show settings to allow configuration of sync settings. 522 * <p> 523 * In some cases, a matching Activity may not exist, so ensure you 524 * safeguard against this. 525 * <p> 526 * The account types available to add via the add account button may be restricted by adding an 527 * {@link #EXTRA_AUTHORITIES} extra to this Intent with one or more syncable content provider's 528 * authorities. Only account types which can sync with that content provider will be offered to 529 * the user. 530 * <p> 531 * Input: Nothing. 532 * <p> 533 * Output: Nothing. 534 */ 535 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 536 public static final String ACTION_SYNC_SETTINGS = 537 "android.settings.SYNC_SETTINGS"; 538 539 /** 540 * Activity Action: Show add account screen for creating a new account. 541 * <p> 542 * In some cases, a matching Activity may not exist, so ensure you 543 * safeguard against this. 544 * <p> 545 * The account types available to add may be restricted by adding an {@link #EXTRA_AUTHORITIES} 546 * extra to the Intent with one or more syncable content provider's authorities. Only account 547 * types which can sync with that content provider will be offered to the user. 548 * <p> 549 * Account types can also be filtered by adding an {@link #EXTRA_ACCOUNT_TYPES} extra to the 550 * Intent with one or more account types. 551 * <p> 552 * Input: Nothing. 553 * <p> 554 * Output: Nothing. 555 */ 556 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 557 public static final String ACTION_ADD_ACCOUNT = 558 "android.settings.ADD_ACCOUNT_SETTINGS"; 559 560 /** 561 * Activity Action: Show settings for selecting the network operator. 562 * <p> 563 * In some cases, a matching Activity may not exist, so ensure you 564 * safeguard against this. 565 * <p> 566 * Input: Nothing. 567 * <p> 568 * Output: Nothing. 569 */ 570 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 571 public static final String ACTION_NETWORK_OPERATOR_SETTINGS = 572 "android.settings.NETWORK_OPERATOR_SETTINGS"; 573 574 /** 575 * Activity Action: Show settings for selection of 2G/3G. 576 * <p> 577 * In some cases, a matching Activity may not exist, so ensure you 578 * safeguard against this. 579 * <p> 580 * Input: Nothing. 581 * <p> 582 * Output: Nothing. 583 */ 584 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 585 public static final String ACTION_DATA_ROAMING_SETTINGS = 586 "android.settings.DATA_ROAMING_SETTINGS"; 587 588 /** 589 * Activity Action: Show settings for internal storage. 590 * <p> 591 * In some cases, a matching Activity may not exist, so ensure you 592 * safeguard against this. 593 * <p> 594 * Input: Nothing. 595 * <p> 596 * Output: Nothing. 597 */ 598 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 599 public static final String ACTION_INTERNAL_STORAGE_SETTINGS = 600 "android.settings.INTERNAL_STORAGE_SETTINGS"; 601 /** 602 * Activity Action: Show settings for memory card storage. 603 * <p> 604 * In some cases, a matching Activity may not exist, so ensure you 605 * safeguard against this. 606 * <p> 607 * Input: Nothing. 608 * <p> 609 * Output: Nothing. 610 */ 611 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 612 public static final String ACTION_MEMORY_CARD_SETTINGS = 613 "android.settings.MEMORY_CARD_SETTINGS"; 614 615 /** 616 * Activity Action: Show settings for global search. 617 * <p> 618 * In some cases, a matching Activity may not exist, so ensure you 619 * safeguard against this. 620 * <p> 621 * Input: Nothing. 622 * <p> 623 * Output: Nothing 624 */ 625 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 626 public static final String ACTION_SEARCH_SETTINGS = 627 "android.search.action.SEARCH_SETTINGS"; 628 629 /** 630 * Activity Action: Show general device information settings (serial 631 * number, software version, phone number, etc.). 632 * <p> 633 * In some cases, a matching Activity may not exist, so ensure you 634 * safeguard against this. 635 * <p> 636 * Input: Nothing. 637 * <p> 638 * Output: Nothing 639 */ 640 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 641 public static final String ACTION_DEVICE_INFO_SETTINGS = 642 "android.settings.DEVICE_INFO_SETTINGS"; 643 644 /** 645 * Activity Action: Show NFC settings. 646 * <p> 647 * This shows UI that allows NFC to be turned on or off. 648 * <p> 649 * In some cases, a matching Activity may not exist, so ensure you 650 * safeguard against this. 651 * <p> 652 * Input: Nothing. 653 * <p> 654 * Output: Nothing 655 * @see android.nfc.NfcAdapter#isEnabled() 656 */ 657 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 658 public static final String ACTION_NFC_SETTINGS = "android.settings.NFC_SETTINGS"; 659 660 /** 661 * Activity Action: Show NFC Sharing settings. 662 * <p> 663 * This shows UI that allows NDEF Push (Android Beam) to be turned on or 664 * off. 665 * <p> 666 * In some cases, a matching Activity may not exist, so ensure you 667 * safeguard against this. 668 * <p> 669 * Input: Nothing. 670 * <p> 671 * Output: Nothing 672 * @see android.nfc.NfcAdapter#isNdefPushEnabled() 673 */ 674 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 675 public static final String ACTION_NFCSHARING_SETTINGS = 676 "android.settings.NFCSHARING_SETTINGS"; 677 678 /** 679 * Activity Action: Show NFC Tap & Pay settings 680 * <p> 681 * This shows UI that allows the user to configure Tap&Pay 682 * settings. 683 * <p> 684 * In some cases, a matching Activity may not exist, so ensure you 685 * safeguard against this. 686 * <p> 687 * Input: Nothing. 688 * <p> 689 * Output: Nothing 690 */ 691 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 692 public static final String ACTION_NFC_PAYMENT_SETTINGS = 693 "android.settings.NFC_PAYMENT_SETTINGS"; 694 695 /** 696 * Activity Action: Show Daydream settings. 697 * <p> 698 * In some cases, a matching Activity may not exist, so ensure you 699 * safeguard against this. 700 * <p> 701 * Input: Nothing. 702 * <p> 703 * Output: Nothing. 704 * @see android.service.dreams.DreamService 705 */ 706 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 707 public static final String ACTION_DREAM_SETTINGS = "android.settings.DREAM_SETTINGS"; 708 709 /** 710 * Activity Action: Show Notification listener settings. 711 * <p> 712 * In some cases, a matching Activity may not exist, so ensure you 713 * safeguard against this. 714 * <p> 715 * Input: Nothing. 716 * <p> 717 * Output: Nothing. 718 * @see android.service.notification.NotificationListenerService 719 * @hide 720 */ 721 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 722 public static final String ACTION_NOTIFICATION_LISTENER_SETTINGS 723 = "android.settings.NOTIFICATION_LISTENER_SETTINGS"; 724 725 /** 726 * Activity Action: Show settings for video captioning. 727 * <p> 728 * In some cases, a matching Activity may not exist, so ensure you safeguard 729 * against this. 730 * <p> 731 * Input: Nothing. 732 * <p> 733 * Output: Nothing. 734 */ 735 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 736 public static final String ACTION_CAPTIONING_SETTINGS = "android.settings.CAPTIONING_SETTINGS"; 737 738 /** 739 * Activity Action: Show the top level print settings. 740 * <p> 741 * In some cases, a matching Activity may not exist, so ensure you 742 * safeguard against this. 743 * <p> 744 * Input: Nothing. 745 * <p> 746 * Output: Nothing. 747 */ 748 @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION) 749 public static final String ACTION_PRINT_SETTINGS = 750 "android.settings.ACTION_PRINT_SETTINGS"; 751 752 // End of Intent actions for Settings 753 754 /** 755 * @hide - Private call() method on SettingsProvider to read from 'system' table. 756 */ 757 public static final String CALL_METHOD_GET_SYSTEM = "GET_system"; 758 759 /** 760 * @hide - Private call() method on SettingsProvider to read from 'secure' table. 761 */ 762 public static final String CALL_METHOD_GET_SECURE = "GET_secure"; 763 764 /** 765 * @hide - Private call() method on SettingsProvider to read from 'global' table. 766 */ 767 public static final String CALL_METHOD_GET_GLOBAL = "GET_global"; 768 769 /** 770 * @hide - User handle argument extra to the fast-path call()-based requests 771 */ 772 public static final String CALL_METHOD_USER_KEY = "_user"; 773 774 /** @hide - Private call() method to write to 'system' table */ 775 public static final String CALL_METHOD_PUT_SYSTEM = "PUT_system"; 776 777 /** @hide - Private call() method to write to 'secure' table */ 778 public static final String CALL_METHOD_PUT_SECURE = "PUT_secure"; 779 780 /** @hide - Private call() method to write to 'global' table */ 781 public static final String CALL_METHOD_PUT_GLOBAL= "PUT_global"; 782 783 /** 784 * Activity Extra: Limit available options in launched activity based on the given authority. 785 * <p> 786 * This can be passed as an extra field in an Activity Intent with one or more syncable content 787 * provider's authorities as a String[]. This field is used by some intents to alter the 788 * behavior of the called activity. 789 * <p> 790 * Example: The {@link #ACTION_ADD_ACCOUNT} intent restricts the account types available based 791 * on the authority given. 792 */ 793 public static final String EXTRA_AUTHORITIES = "authorities"; 794 795 /** 796 * Activity Extra: Limit available options in launched activity based on the given account 797 * types. 798 * <p> 799 * This can be passed as an extra field in an Activity Intent with one or more account types 800 * as a String[]. This field is used by some intents to alter the behavior of the called 801 * activity. 802 * <p> 803 * Example: The {@link #ACTION_ADD_ACCOUNT} intent restricts the account types to the specified 804 * list. 805 */ 806 public static final String EXTRA_ACCOUNT_TYPES = "account_types"; 807 808 public static final String EXTRA_INPUT_METHOD_ID = "input_method_id"; 809 810 private static final String JID_RESOURCE_PREFIX = "android"; 811 812 public static final String AUTHORITY = "settings"; 813 814 private static final String TAG = "Settings"; 815 private static final boolean LOCAL_LOGV = false; 816 817 // Lock ensures that when enabling/disabling the master location switch, we don't end up 818 // with a partial enable/disable state in multi-threaded situations. 819 private static final Object mLocationSettingsLock = new Object(); 820 821 public static class SettingNotFoundException extends AndroidException { SettingNotFoundException(String msg)822 public SettingNotFoundException(String msg) { 823 super(msg); 824 } 825 } 826 827 /** 828 * Common base for tables of name/value settings. 829 */ 830 public static class NameValueTable implements BaseColumns { 831 public static final String NAME = "name"; 832 public static final String VALUE = "value"; 833 putString(ContentResolver resolver, Uri uri, String name, String value)834 protected static boolean putString(ContentResolver resolver, Uri uri, 835 String name, String value) { 836 // The database will take care of replacing duplicates. 837 try { 838 ContentValues values = new ContentValues(); 839 values.put(NAME, name); 840 values.put(VALUE, value); 841 resolver.insert(uri, values); 842 return true; 843 } catch (SQLException e) { 844 Log.w(TAG, "Can't set key " + name + " in " + uri, e); 845 return false; 846 } 847 } 848 getUriFor(Uri uri, String name)849 public static Uri getUriFor(Uri uri, String name) { 850 return Uri.withAppendedPath(uri, name); 851 } 852 } 853 854 // Thread-safe. 855 private static class NameValueCache { 856 private final String mVersionSystemProperty; 857 private final Uri mUri; 858 859 private static final String[] SELECT_VALUE = 860 new String[] { Settings.NameValueTable.VALUE }; 861 private static final String NAME_EQ_PLACEHOLDER = "name=?"; 862 863 // Must synchronize on 'this' to access mValues and mValuesVersion. 864 private final HashMap<String, String> mValues = new HashMap<String, String>(); 865 private long mValuesVersion = 0; 866 867 // Initially null; set lazily and held forever. Synchronized on 'this'. 868 private IContentProvider mContentProvider = null; 869 870 // The method we'll call (or null, to not use) on the provider 871 // for the fast path of retrieving settings. 872 private final String mCallGetCommand; 873 private final String mCallSetCommand; 874 NameValueCache(String versionSystemProperty, Uri uri, String getCommand, String setCommand)875 public NameValueCache(String versionSystemProperty, Uri uri, 876 String getCommand, String setCommand) { 877 mVersionSystemProperty = versionSystemProperty; 878 mUri = uri; 879 mCallGetCommand = getCommand; 880 mCallSetCommand = setCommand; 881 } 882 lazyGetProvider(ContentResolver cr)883 private IContentProvider lazyGetProvider(ContentResolver cr) { 884 IContentProvider cp = null; 885 synchronized (this) { 886 cp = mContentProvider; 887 if (cp == null) { 888 cp = mContentProvider = cr.acquireProvider(mUri.getAuthority()); 889 } 890 } 891 return cp; 892 } 893 putStringForUser(ContentResolver cr, String name, String value, final int userHandle)894 public boolean putStringForUser(ContentResolver cr, String name, String value, 895 final int userHandle) { 896 try { 897 Bundle arg = new Bundle(); 898 arg.putString(Settings.NameValueTable.VALUE, value); 899 arg.putInt(CALL_METHOD_USER_KEY, userHandle); 900 IContentProvider cp = lazyGetProvider(cr); 901 cp.call(cr.getPackageName(), mCallSetCommand, name, arg); 902 } catch (RemoteException e) { 903 Log.w(TAG, "Can't set key " + name + " in " + mUri, e); 904 return false; 905 } 906 return true; 907 } 908 getStringForUser(ContentResolver cr, String name, final int userHandle)909 public String getStringForUser(ContentResolver cr, String name, final int userHandle) { 910 final boolean isSelf = (userHandle == UserHandle.myUserId()); 911 if (isSelf) { 912 long newValuesVersion = SystemProperties.getLong(mVersionSystemProperty, 0); 913 914 // Our own user's settings data uses a client-side cache 915 synchronized (this) { 916 if (mValuesVersion != newValuesVersion) { 917 if (LOCAL_LOGV || false) { 918 Log.v(TAG, "invalidate [" + mUri.getLastPathSegment() + "]: current " 919 + newValuesVersion + " != cached " + mValuesVersion); 920 } 921 922 mValues.clear(); 923 mValuesVersion = newValuesVersion; 924 } 925 926 if (mValues.containsKey(name)) { 927 return mValues.get(name); // Could be null, that's OK -- negative caching 928 } 929 } 930 } else { 931 if (LOCAL_LOGV) Log.v(TAG, "get setting for user " + userHandle 932 + " by user " + UserHandle.myUserId() + " so skipping cache"); 933 } 934 935 IContentProvider cp = lazyGetProvider(cr); 936 937 // Try the fast path first, not using query(). If this 938 // fails (alternate Settings provider that doesn't support 939 // this interface?) then we fall back to the query/table 940 // interface. 941 if (mCallGetCommand != null) { 942 try { 943 Bundle args = null; 944 if (!isSelf) { 945 args = new Bundle(); 946 args.putInt(CALL_METHOD_USER_KEY, userHandle); 947 } 948 Bundle b = cp.call(cr.getPackageName(), mCallGetCommand, name, args); 949 if (b != null) { 950 String value = b.getPairValue(); 951 // Don't update our cache for reads of other users' data 952 if (isSelf) { 953 synchronized (this) { 954 mValues.put(name, value); 955 } 956 } else { 957 if (LOCAL_LOGV) Log.i(TAG, "call-query of user " + userHandle 958 + " by " + UserHandle.myUserId() 959 + " so not updating cache"); 960 } 961 return value; 962 } 963 // If the response Bundle is null, we fall through 964 // to the query interface below. 965 } catch (RemoteException e) { 966 // Not supported by the remote side? Fall through 967 // to query(). 968 } 969 } 970 971 Cursor c = null; 972 try { 973 c = cp.query(cr.getPackageName(), mUri, SELECT_VALUE, NAME_EQ_PLACEHOLDER, 974 new String[]{name}, null, null); 975 if (c == null) { 976 Log.w(TAG, "Can't get key " + name + " from " + mUri); 977 return null; 978 } 979 980 String value = c.moveToNext() ? c.getString(0) : null; 981 synchronized (this) { 982 mValues.put(name, value); 983 } 984 if (LOCAL_LOGV) { 985 Log.v(TAG, "cache miss [" + mUri.getLastPathSegment() + "]: " + 986 name + " = " + (value == null ? "(null)" : value)); 987 } 988 return value; 989 } catch (RemoteException e) { 990 Log.w(TAG, "Can't get key " + name + " from " + mUri, e); 991 return null; // Return null, but don't cache it. 992 } finally { 993 if (c != null) c.close(); 994 } 995 } 996 } 997 998 /** 999 * System settings, containing miscellaneous system preferences. This 1000 * table holds simple name/value pairs. There are convenience 1001 * functions for accessing individual settings entries. 1002 */ 1003 public static final class System extends NameValueTable { 1004 public static final String SYS_PROP_SETTING_VERSION = "sys.settings_system_version"; 1005 1006 /** 1007 * The content:// style URL for this table 1008 */ 1009 public static final Uri CONTENT_URI = 1010 Uri.parse("content://" + AUTHORITY + "/system"); 1011 1012 private static final NameValueCache sNameValueCache = new NameValueCache( 1013 SYS_PROP_SETTING_VERSION, 1014 CONTENT_URI, 1015 CALL_METHOD_GET_SYSTEM, 1016 CALL_METHOD_PUT_SYSTEM); 1017 1018 private static final HashSet<String> MOVED_TO_SECURE; 1019 static { 1020 MOVED_TO_SECURE = new HashSet<String>(30); 1021 MOVED_TO_SECURE.add(Secure.ANDROID_ID); 1022 MOVED_TO_SECURE.add(Secure.HTTP_PROXY); 1023 MOVED_TO_SECURE.add(Secure.LOCATION_PROVIDERS_ALLOWED); 1024 MOVED_TO_SECURE.add(Secure.LOCK_BIOMETRIC_WEAK_FLAGS); 1025 MOVED_TO_SECURE.add(Secure.LOCK_PATTERN_ENABLED); 1026 MOVED_TO_SECURE.add(Secure.LOCK_PATTERN_VISIBLE); 1027 MOVED_TO_SECURE.add(Secure.LOCK_PATTERN_TACTILE_FEEDBACK_ENABLED); 1028 MOVED_TO_SECURE.add(Secure.LOGGING_ID); 1029 MOVED_TO_SECURE.add(Secure.PARENTAL_CONTROL_ENABLED); 1030 MOVED_TO_SECURE.add(Secure.PARENTAL_CONTROL_LAST_UPDATE); 1031 MOVED_TO_SECURE.add(Secure.PARENTAL_CONTROL_REDIRECT_URL); 1032 MOVED_TO_SECURE.add(Secure.SETTINGS_CLASSNAME); 1033 MOVED_TO_SECURE.add(Secure.USE_GOOGLE_MAIL); 1034 MOVED_TO_SECURE.add(Secure.WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON); 1035 MOVED_TO_SECURE.add(Secure.WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY); 1036 MOVED_TO_SECURE.add(Secure.WIFI_NUM_OPEN_NETWORKS_KEPT); 1037 MOVED_TO_SECURE.add(Secure.WIFI_ON); 1038 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_ACCEPTABLE_PACKET_LOSS_PERCENTAGE); 1039 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_AP_COUNT); 1040 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_BACKGROUND_CHECK_DELAY_MS); 1041 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_BACKGROUND_CHECK_ENABLED); 1042 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_BACKGROUND_CHECK_TIMEOUT_MS); 1043 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_INITIAL_IGNORED_PING_COUNT); 1044 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_MAX_AP_CHECKS); 1045 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_ON); 1046 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_PING_COUNT); 1047 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_PING_DELAY_MS); 1048 MOVED_TO_SECURE.add(Secure.WIFI_WATCHDOG_PING_TIMEOUT_MS); 1049 } 1050 1051 private static final HashSet<String> MOVED_TO_GLOBAL; 1052 private static final HashSet<String> MOVED_TO_SECURE_THEN_GLOBAL; 1053 static { 1054 MOVED_TO_GLOBAL = new HashSet<String>(); 1055 MOVED_TO_SECURE_THEN_GLOBAL = new HashSet<String>(); 1056 1057 // these were originally in system but migrated to secure in the past, 1058 // so are duplicated in the Secure.* namespace 1059 MOVED_TO_SECURE_THEN_GLOBAL.add(Global.ADB_ENABLED); 1060 MOVED_TO_SECURE_THEN_GLOBAL.add(Global.BLUETOOTH_ON); 1061 MOVED_TO_SECURE_THEN_GLOBAL.add(Global.DATA_ROAMING); 1062 MOVED_TO_SECURE_THEN_GLOBAL.add(Global.DEVICE_PROVISIONED); 1063 MOVED_TO_SECURE_THEN_GLOBAL.add(Global.INSTALL_NON_MARKET_APPS); 1064 MOVED_TO_SECURE_THEN_GLOBAL.add(Global.USB_MASS_STORAGE_ENABLED); 1065 MOVED_TO_SECURE_THEN_GLOBAL.add(Global.HTTP_PROXY); 1066 1067 // these are moving directly from system to global 1068 MOVED_TO_GLOBAL.add(Settings.Global.AIRPLANE_MODE_ON); 1069 MOVED_TO_GLOBAL.add(Settings.Global.AIRPLANE_MODE_RADIOS); 1070 MOVED_TO_GLOBAL.add(Settings.Global.AIRPLANE_MODE_TOGGLEABLE_RADIOS); 1071 MOVED_TO_GLOBAL.add(Settings.Global.AUTO_TIME); 1072 MOVED_TO_GLOBAL.add(Settings.Global.AUTO_TIME_ZONE); 1073 MOVED_TO_GLOBAL.add(Settings.Global.CAR_DOCK_SOUND); 1074 MOVED_TO_GLOBAL.add(Settings.Global.CAR_UNDOCK_SOUND); 1075 MOVED_TO_GLOBAL.add(Settings.Global.DESK_DOCK_SOUND); 1076 MOVED_TO_GLOBAL.add(Settings.Global.DESK_UNDOCK_SOUND); 1077 MOVED_TO_GLOBAL.add(Settings.Global.DOCK_SOUNDS_ENABLED); 1078 MOVED_TO_GLOBAL.add(Settings.Global.LOCK_SOUND); 1079 MOVED_TO_GLOBAL.add(Settings.Global.UNLOCK_SOUND); 1080 MOVED_TO_GLOBAL.add(Settings.Global.LOW_BATTERY_SOUND); 1081 MOVED_TO_GLOBAL.add(Settings.Global.POWER_SOUNDS_ENABLED); 1082 MOVED_TO_GLOBAL.add(Settings.Global.STAY_ON_WHILE_PLUGGED_IN); 1083 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_SLEEP_POLICY); 1084 MOVED_TO_GLOBAL.add(Settings.Global.MODE_RINGER); 1085 MOVED_TO_GLOBAL.add(Settings.Global.WINDOW_ANIMATION_SCALE); 1086 MOVED_TO_GLOBAL.add(Settings.Global.TRANSITION_ANIMATION_SCALE); 1087 MOVED_TO_GLOBAL.add(Settings.Global.ANIMATOR_DURATION_SCALE); 1088 MOVED_TO_GLOBAL.add(Settings.Global.FANCY_IME_ANIMATIONS); 1089 MOVED_TO_GLOBAL.add(Settings.Global.COMPATIBILITY_MODE); 1090 MOVED_TO_GLOBAL.add(Settings.Global.EMERGENCY_TONE); 1091 MOVED_TO_GLOBAL.add(Settings.Global.CALL_AUTO_RETRY); 1092 MOVED_TO_GLOBAL.add(Settings.Global.DEBUG_APP); 1093 MOVED_TO_GLOBAL.add(Settings.Global.WAIT_FOR_DEBUGGER); 1094 MOVED_TO_GLOBAL.add(Settings.Global.SHOW_PROCESSES); 1095 MOVED_TO_GLOBAL.add(Settings.Global.ALWAYS_FINISH_ACTIVITIES); 1096 MOVED_TO_GLOBAL.add(Settings.Global.TZINFO_UPDATE_CONTENT_URL); 1097 MOVED_TO_GLOBAL.add(Settings.Global.TZINFO_UPDATE_METADATA_URL); 1098 MOVED_TO_GLOBAL.add(Settings.Global.SELINUX_UPDATE_CONTENT_URL); 1099 MOVED_TO_GLOBAL.add(Settings.Global.SELINUX_UPDATE_METADATA_URL); 1100 MOVED_TO_GLOBAL.add(Settings.Global.SMS_SHORT_CODES_UPDATE_CONTENT_URL); 1101 MOVED_TO_GLOBAL.add(Settings.Global.SMS_SHORT_CODES_UPDATE_METADATA_URL); 1102 MOVED_TO_GLOBAL.add(Settings.Global.CERT_PIN_UPDATE_CONTENT_URL); 1103 MOVED_TO_GLOBAL.add(Settings.Global.CERT_PIN_UPDATE_METADATA_URL); 1104 } 1105 1106 /** @hide */ getMovedKeys(HashSet<String> outKeySet)1107 public static void getMovedKeys(HashSet<String> outKeySet) { 1108 outKeySet.addAll(MOVED_TO_GLOBAL); 1109 outKeySet.addAll(MOVED_TO_SECURE_THEN_GLOBAL); 1110 } 1111 1112 /** @hide */ getNonLegacyMovedKeys(HashSet<String> outKeySet)1113 public static void getNonLegacyMovedKeys(HashSet<String> outKeySet) { 1114 outKeySet.addAll(MOVED_TO_GLOBAL); 1115 } 1116 1117 /** 1118 * Look up a name in the database. 1119 * @param resolver to access the database with 1120 * @param name to look up in the table 1121 * @return the corresponding value, or null if not present 1122 */ getString(ContentResolver resolver, String name)1123 public static String getString(ContentResolver resolver, String name) { 1124 return getStringForUser(resolver, name, UserHandle.myUserId()); 1125 } 1126 1127 /** @hide */ getStringForUser(ContentResolver resolver, String name, int userHandle)1128 public static String getStringForUser(ContentResolver resolver, String name, 1129 int userHandle) { 1130 if (MOVED_TO_SECURE.contains(name)) { 1131 Log.w(TAG, "Setting " + name + " has moved from android.provider.Settings.System" 1132 + " to android.provider.Settings.Secure, returning read-only value."); 1133 return Secure.getStringForUser(resolver, name, userHandle); 1134 } 1135 if (MOVED_TO_GLOBAL.contains(name) || MOVED_TO_SECURE_THEN_GLOBAL.contains(name)) { 1136 Log.w(TAG, "Setting " + name + " has moved from android.provider.Settings.System" 1137 + " to android.provider.Settings.Global, returning read-only value."); 1138 return Global.getStringForUser(resolver, name, userHandle); 1139 } 1140 return sNameValueCache.getStringForUser(resolver, name, userHandle); 1141 } 1142 1143 /** 1144 * Store a name/value pair into the database. 1145 * @param resolver to access the database with 1146 * @param name to store 1147 * @param value to associate with the name 1148 * @return true if the value was set, false on database errors 1149 */ putString(ContentResolver resolver, String name, String value)1150 public static boolean putString(ContentResolver resolver, String name, String value) { 1151 return putStringForUser(resolver, name, value, UserHandle.myUserId()); 1152 } 1153 1154 /** @hide */ putStringForUser(ContentResolver resolver, String name, String value, int userHandle)1155 public static boolean putStringForUser(ContentResolver resolver, String name, String value, 1156 int userHandle) { 1157 if (MOVED_TO_SECURE.contains(name)) { 1158 Log.w(TAG, "Setting " + name + " has moved from android.provider.Settings.System" 1159 + " to android.provider.Settings.Secure, value is unchanged."); 1160 return false; 1161 } 1162 if (MOVED_TO_GLOBAL.contains(name) || MOVED_TO_SECURE_THEN_GLOBAL.contains(name)) { 1163 Log.w(TAG, "Setting " + name + " has moved from android.provider.Settings.System" 1164 + " to android.provider.Settings.Global, value is unchanged."); 1165 return false; 1166 } 1167 return sNameValueCache.putStringForUser(resolver, name, value, userHandle); 1168 } 1169 1170 /** 1171 * Construct the content URI for a particular name/value pair, 1172 * useful for monitoring changes with a ContentObserver. 1173 * @param name to look up in the table 1174 * @return the corresponding content URI, or null if not present 1175 */ getUriFor(String name)1176 public static Uri getUriFor(String name) { 1177 if (MOVED_TO_SECURE.contains(name)) { 1178 Log.w(TAG, "Setting " + name + " has moved from android.provider.Settings.System" 1179 + " to android.provider.Settings.Secure, returning Secure URI."); 1180 return Secure.getUriFor(Secure.CONTENT_URI, name); 1181 } 1182 if (MOVED_TO_GLOBAL.contains(name) || MOVED_TO_SECURE_THEN_GLOBAL.contains(name)) { 1183 Log.w(TAG, "Setting " + name + " has moved from android.provider.Settings.System" 1184 + " to android.provider.Settings.Global, returning read-only global URI."); 1185 return Global.getUriFor(Global.CONTENT_URI, name); 1186 } 1187 return getUriFor(CONTENT_URI, name); 1188 } 1189 1190 /** 1191 * Convenience function for retrieving a single system settings value 1192 * as an integer. Note that internally setting values are always 1193 * stored as strings; this function converts the string to an integer 1194 * for you. The default value will be returned if the setting is 1195 * not defined or not an integer. 1196 * 1197 * @param cr The ContentResolver to access. 1198 * @param name The name of the setting to retrieve. 1199 * @param def Value to return if the setting is not defined. 1200 * 1201 * @return The setting's current value, or 'def' if it is not defined 1202 * or not a valid integer. 1203 */ getInt(ContentResolver cr, String name, int def)1204 public static int getInt(ContentResolver cr, String name, int def) { 1205 return getIntForUser(cr, name, def, UserHandle.myUserId()); 1206 } 1207 1208 /** @hide */ getIntForUser(ContentResolver cr, String name, int def, int userHandle)1209 public static int getIntForUser(ContentResolver cr, String name, int def, int userHandle) { 1210 String v = getStringForUser(cr, name, userHandle); 1211 try { 1212 return v != null ? Integer.parseInt(v) : def; 1213 } catch (NumberFormatException e) { 1214 return def; 1215 } 1216 } 1217 1218 /** 1219 * Convenience function for retrieving a single system settings value 1220 * as an integer. Note that internally setting values are always 1221 * stored as strings; this function converts the string to an integer 1222 * for you. 1223 * <p> 1224 * This version does not take a default value. If the setting has not 1225 * been set, or the string value is not a number, 1226 * it throws {@link SettingNotFoundException}. 1227 * 1228 * @param cr The ContentResolver to access. 1229 * @param name The name of the setting to retrieve. 1230 * 1231 * @throws SettingNotFoundException Thrown if a setting by the given 1232 * name can't be found or the setting value is not an integer. 1233 * 1234 * @return The setting's current value. 1235 */ getInt(ContentResolver cr, String name)1236 public static int getInt(ContentResolver cr, String name) 1237 throws SettingNotFoundException { 1238 return getIntForUser(cr, name, UserHandle.myUserId()); 1239 } 1240 1241 /** @hide */ getIntForUser(ContentResolver cr, String name, int userHandle)1242 public static int getIntForUser(ContentResolver cr, String name, int userHandle) 1243 throws SettingNotFoundException { 1244 String v = getStringForUser(cr, name, userHandle); 1245 try { 1246 return Integer.parseInt(v); 1247 } catch (NumberFormatException e) { 1248 throw new SettingNotFoundException(name); 1249 } 1250 } 1251 1252 /** 1253 * Convenience function for updating a single settings value as an 1254 * integer. This will either create a new entry in the table if the 1255 * given name does not exist, or modify the value of the existing row 1256 * with that name. Note that internally setting values are always 1257 * stored as strings, so this function converts the given value to a 1258 * string before storing it. 1259 * 1260 * @param cr The ContentResolver to access. 1261 * @param name The name of the setting to modify. 1262 * @param value The new value for the setting. 1263 * @return true if the value was set, false on database errors 1264 */ putInt(ContentResolver cr, String name, int value)1265 public static boolean putInt(ContentResolver cr, String name, int value) { 1266 return putIntForUser(cr, name, value, UserHandle.myUserId()); 1267 } 1268 1269 /** @hide */ putIntForUser(ContentResolver cr, String name, int value, int userHandle)1270 public static boolean putIntForUser(ContentResolver cr, String name, int value, 1271 int userHandle) { 1272 return putStringForUser(cr, name, Integer.toString(value), userHandle); 1273 } 1274 1275 /** 1276 * Convenience function for retrieving a single system settings value 1277 * as a {@code long}. Note that internally setting values are always 1278 * stored as strings; this function converts the string to a {@code long} 1279 * for you. The default value will be returned if the setting is 1280 * not defined or not a {@code long}. 1281 * 1282 * @param cr The ContentResolver to access. 1283 * @param name The name of the setting to retrieve. 1284 * @param def Value to return if the setting is not defined. 1285 * 1286 * @return The setting's current value, or 'def' if it is not defined 1287 * or not a valid {@code long}. 1288 */ getLong(ContentResolver cr, String name, long def)1289 public static long getLong(ContentResolver cr, String name, long def) { 1290 return getLongForUser(cr, name, def, UserHandle.myUserId()); 1291 } 1292 1293 /** @hide */ getLongForUser(ContentResolver cr, String name, long def, int userHandle)1294 public static long getLongForUser(ContentResolver cr, String name, long def, 1295 int userHandle) { 1296 String valString = getStringForUser(cr, name, userHandle); 1297 long value; 1298 try { 1299 value = valString != null ? Long.parseLong(valString) : def; 1300 } catch (NumberFormatException e) { 1301 value = def; 1302 } 1303 return value; 1304 } 1305 1306 /** 1307 * Convenience function for retrieving a single system settings value 1308 * as a {@code long}. Note that internally setting values are always 1309 * stored as strings; this function converts the string to a {@code long} 1310 * for you. 1311 * <p> 1312 * This version does not take a default value. If the setting has not 1313 * been set, or the string value is not a number, 1314 * it throws {@link SettingNotFoundException}. 1315 * 1316 * @param cr The ContentResolver to access. 1317 * @param name The name of the setting to retrieve. 1318 * 1319 * @return The setting's current value. 1320 * @throws SettingNotFoundException Thrown if a setting by the given 1321 * name can't be found or the setting value is not an integer. 1322 */ getLong(ContentResolver cr, String name)1323 public static long getLong(ContentResolver cr, String name) 1324 throws SettingNotFoundException { 1325 return getLongForUser(cr, name, UserHandle.myUserId()); 1326 } 1327 1328 /** @hide */ getLongForUser(ContentResolver cr, String name, int userHandle)1329 public static long getLongForUser(ContentResolver cr, String name, int userHandle) 1330 throws SettingNotFoundException { 1331 String valString = getStringForUser(cr, name, userHandle); 1332 try { 1333 return Long.parseLong(valString); 1334 } catch (NumberFormatException e) { 1335 throw new SettingNotFoundException(name); 1336 } 1337 } 1338 1339 /** 1340 * Convenience function for updating a single settings value as a long 1341 * integer. This will either create a new entry in the table if the 1342 * given name does not exist, or modify the value of the existing row 1343 * with that name. Note that internally setting values are always 1344 * stored as strings, so this function converts the given value to a 1345 * string before storing it. 1346 * 1347 * @param cr The ContentResolver to access. 1348 * @param name The name of the setting to modify. 1349 * @param value The new value for the setting. 1350 * @return true if the value was set, false on database errors 1351 */ putLong(ContentResolver cr, String name, long value)1352 public static boolean putLong(ContentResolver cr, String name, long value) { 1353 return putLongForUser(cr, name, value, UserHandle.myUserId()); 1354 } 1355 1356 /** @hide */ putLongForUser(ContentResolver cr, String name, long value, int userHandle)1357 public static boolean putLongForUser(ContentResolver cr, String name, long value, 1358 int userHandle) { 1359 return putStringForUser(cr, name, Long.toString(value), userHandle); 1360 } 1361 1362 /** 1363 * Convenience function for retrieving a single system settings value 1364 * as a floating point number. Note that internally setting values are 1365 * always stored as strings; this function converts the string to an 1366 * float for you. The default value will be returned if the setting 1367 * is not defined or not a valid float. 1368 * 1369 * @param cr The ContentResolver to access. 1370 * @param name The name of the setting to retrieve. 1371 * @param def Value to return if the setting is not defined. 1372 * 1373 * @return The setting's current value, or 'def' if it is not defined 1374 * or not a valid float. 1375 */ getFloat(ContentResolver cr, String name, float def)1376 public static float getFloat(ContentResolver cr, String name, float def) { 1377 return getFloatForUser(cr, name, def, UserHandle.myUserId()); 1378 } 1379 1380 /** @hide */ getFloatForUser(ContentResolver cr, String name, float def, int userHandle)1381 public static float getFloatForUser(ContentResolver cr, String name, float def, 1382 int userHandle) { 1383 String v = getStringForUser(cr, name, userHandle); 1384 try { 1385 return v != null ? Float.parseFloat(v) : def; 1386 } catch (NumberFormatException e) { 1387 return def; 1388 } 1389 } 1390 1391 /** 1392 * Convenience function for retrieving a single system settings value 1393 * as a float. Note that internally setting values are always 1394 * stored as strings; this function converts the string to a float 1395 * for you. 1396 * <p> 1397 * This version does not take a default value. If the setting has not 1398 * been set, or the string value is not a number, 1399 * it throws {@link SettingNotFoundException}. 1400 * 1401 * @param cr The ContentResolver to access. 1402 * @param name The name of the setting to retrieve. 1403 * 1404 * @throws SettingNotFoundException Thrown if a setting by the given 1405 * name can't be found or the setting value is not a float. 1406 * 1407 * @return The setting's current value. 1408 */ getFloat(ContentResolver cr, String name)1409 public static float getFloat(ContentResolver cr, String name) 1410 throws SettingNotFoundException { 1411 return getFloatForUser(cr, name, UserHandle.myUserId()); 1412 } 1413 1414 /** @hide */ getFloatForUser(ContentResolver cr, String name, int userHandle)1415 public static float getFloatForUser(ContentResolver cr, String name, int userHandle) 1416 throws SettingNotFoundException { 1417 String v = getStringForUser(cr, name, userHandle); 1418 if (v == null) { 1419 throw new SettingNotFoundException(name); 1420 } 1421 try { 1422 return Float.parseFloat(v); 1423 } catch (NumberFormatException e) { 1424 throw new SettingNotFoundException(name); 1425 } 1426 } 1427 1428 /** 1429 * Convenience function for updating a single settings value as a 1430 * floating point number. This will either create a new entry in the 1431 * table if the given name does not exist, or modify the value of the 1432 * existing row with that name. Note that internally setting values 1433 * are always stored as strings, so this function converts the given 1434 * value to a string before storing it. 1435 * 1436 * @param cr The ContentResolver to access. 1437 * @param name The name of the setting to modify. 1438 * @param value The new value for the setting. 1439 * @return true if the value was set, false on database errors 1440 */ putFloat(ContentResolver cr, String name, float value)1441 public static boolean putFloat(ContentResolver cr, String name, float value) { 1442 return putFloatForUser(cr, name, value, UserHandle.myUserId()); 1443 } 1444 1445 /** @hide */ putFloatForUser(ContentResolver cr, String name, float value, int userHandle)1446 public static boolean putFloatForUser(ContentResolver cr, String name, float value, 1447 int userHandle) { 1448 return putStringForUser(cr, name, Float.toString(value), userHandle); 1449 } 1450 1451 /** 1452 * Convenience function to read all of the current 1453 * configuration-related settings into a 1454 * {@link Configuration} object. 1455 * 1456 * @param cr The ContentResolver to access. 1457 * @param outConfig Where to place the configuration settings. 1458 */ getConfiguration(ContentResolver cr, Configuration outConfig)1459 public static void getConfiguration(ContentResolver cr, Configuration outConfig) { 1460 getConfigurationForUser(cr, outConfig, UserHandle.myUserId()); 1461 } 1462 1463 /** @hide */ getConfigurationForUser(ContentResolver cr, Configuration outConfig, int userHandle)1464 public static void getConfigurationForUser(ContentResolver cr, Configuration outConfig, 1465 int userHandle) { 1466 outConfig.fontScale = Settings.System.getFloatForUser( 1467 cr, FONT_SCALE, outConfig.fontScale, userHandle); 1468 if (outConfig.fontScale < 0) { 1469 outConfig.fontScale = 1; 1470 } 1471 } 1472 1473 /** 1474 * @hide Erase the fields in the Configuration that should be applied 1475 * by the settings. 1476 */ clearConfiguration(Configuration inoutConfig)1477 public static void clearConfiguration(Configuration inoutConfig) { 1478 inoutConfig.fontScale = 0; 1479 } 1480 1481 /** 1482 * Convenience function to write a batch of configuration-related 1483 * settings from a {@link Configuration} object. 1484 * 1485 * @param cr The ContentResolver to access. 1486 * @param config The settings to write. 1487 * @return true if the values were set, false on database errors 1488 */ putConfiguration(ContentResolver cr, Configuration config)1489 public static boolean putConfiguration(ContentResolver cr, Configuration config) { 1490 return putConfigurationForUser(cr, config, UserHandle.myUserId()); 1491 } 1492 1493 /** @hide */ putConfigurationForUser(ContentResolver cr, Configuration config, int userHandle)1494 public static boolean putConfigurationForUser(ContentResolver cr, Configuration config, 1495 int userHandle) { 1496 return Settings.System.putFloatForUser(cr, FONT_SCALE, config.fontScale, userHandle); 1497 } 1498 1499 /** @hide */ hasInterestingConfigurationChanges(int changes)1500 public static boolean hasInterestingConfigurationChanges(int changes) { 1501 return (changes&ActivityInfo.CONFIG_FONT_SCALE) != 0; 1502 } 1503 1504 /** @deprecated - Do not use */ 1505 @Deprecated getShowGTalkServiceStatus(ContentResolver cr)1506 public static boolean getShowGTalkServiceStatus(ContentResolver cr) { 1507 return getShowGTalkServiceStatusForUser(cr, UserHandle.myUserId()); 1508 } 1509 1510 /** 1511 * @hide 1512 * @deprecated - Do not use 1513 */ getShowGTalkServiceStatusForUser(ContentResolver cr, int userHandle)1514 public static boolean getShowGTalkServiceStatusForUser(ContentResolver cr, 1515 int userHandle) { 1516 return getIntForUser(cr, SHOW_GTALK_SERVICE_STATUS, 0, userHandle) != 0; 1517 } 1518 1519 /** @deprecated - Do not use */ 1520 @Deprecated setShowGTalkServiceStatus(ContentResolver cr, boolean flag)1521 public static void setShowGTalkServiceStatus(ContentResolver cr, boolean flag) { 1522 setShowGTalkServiceStatusForUser(cr, flag, UserHandle.myUserId()); 1523 } 1524 1525 /** 1526 * @hide 1527 * @deprecated - Do not use 1528 */ 1529 @Deprecated setShowGTalkServiceStatusForUser(ContentResolver cr, boolean flag, int userHandle)1530 public static void setShowGTalkServiceStatusForUser(ContentResolver cr, boolean flag, 1531 int userHandle) { 1532 putIntForUser(cr, SHOW_GTALK_SERVICE_STATUS, flag ? 1 : 0, userHandle); 1533 } 1534 1535 /** 1536 * @deprecated Use {@link android.provider.Settings.Global#STAY_ON_WHILE_PLUGGED_IN} instead 1537 */ 1538 @Deprecated 1539 public static final String STAY_ON_WHILE_PLUGGED_IN = Global.STAY_ON_WHILE_PLUGGED_IN; 1540 1541 /** 1542 * What happens when the user presses the end call button if they're not 1543 * on a call.<br/> 1544 * <b>Values:</b><br/> 1545 * 0 - The end button does nothing.<br/> 1546 * 1 - The end button goes to the home screen.<br/> 1547 * 2 - The end button puts the device to sleep and locks the keyguard.<br/> 1548 * 3 - The end button goes to the home screen. If the user is already on the 1549 * home screen, it puts the device to sleep. 1550 */ 1551 public static final String END_BUTTON_BEHAVIOR = "end_button_behavior"; 1552 1553 /** 1554 * END_BUTTON_BEHAVIOR value for "go home". 1555 * @hide 1556 */ 1557 public static final int END_BUTTON_BEHAVIOR_HOME = 0x1; 1558 1559 /** 1560 * END_BUTTON_BEHAVIOR value for "go to sleep". 1561 * @hide 1562 */ 1563 public static final int END_BUTTON_BEHAVIOR_SLEEP = 0x2; 1564 1565 /** 1566 * END_BUTTON_BEHAVIOR default value. 1567 * @hide 1568 */ 1569 public static final int END_BUTTON_BEHAVIOR_DEFAULT = END_BUTTON_BEHAVIOR_SLEEP; 1570 1571 /** 1572 * Is advanced settings mode turned on. 0 == no, 1 == yes 1573 * @hide 1574 */ 1575 public static final String ADVANCED_SETTINGS = "advanced_settings"; 1576 1577 /** 1578 * ADVANCED_SETTINGS default value. 1579 * @hide 1580 */ 1581 public static final int ADVANCED_SETTINGS_DEFAULT = 0; 1582 1583 /** 1584 * @deprecated Use {@link android.provider.Settings.Global#AIRPLANE_MODE_ON} instead 1585 */ 1586 @Deprecated 1587 public static final String AIRPLANE_MODE_ON = Global.AIRPLANE_MODE_ON; 1588 1589 /** 1590 * @deprecated Use {@link android.provider.Settings.Global#RADIO_BLUETOOTH} instead 1591 */ 1592 @Deprecated 1593 public static final String RADIO_BLUETOOTH = Global.RADIO_BLUETOOTH; 1594 1595 /** 1596 * @deprecated Use {@link android.provider.Settings.Global#RADIO_WIFI} instead 1597 */ 1598 @Deprecated 1599 public static final String RADIO_WIFI = Global.RADIO_WIFI; 1600 1601 /** 1602 * @deprecated Use {@link android.provider.Settings.Global#RADIO_WIMAX} instead 1603 * {@hide} 1604 */ 1605 @Deprecated 1606 public static final String RADIO_WIMAX = Global.RADIO_WIMAX; 1607 1608 /** 1609 * @deprecated Use {@link android.provider.Settings.Global#RADIO_CELL} instead 1610 */ 1611 @Deprecated 1612 public static final String RADIO_CELL = Global.RADIO_CELL; 1613 1614 /** 1615 * @deprecated Use {@link android.provider.Settings.Global#RADIO_NFC} instead 1616 */ 1617 @Deprecated 1618 public static final String RADIO_NFC = Global.RADIO_NFC; 1619 1620 /** 1621 * @deprecated Use {@link android.provider.Settings.Global#AIRPLANE_MODE_RADIOS} instead 1622 */ 1623 @Deprecated 1624 public static final String AIRPLANE_MODE_RADIOS = Global.AIRPLANE_MODE_RADIOS; 1625 1626 /** 1627 * @deprecated Use {@link android.provider.Settings.Global#AIRPLANE_MODE_TOGGLEABLE_RADIOS} instead 1628 * 1629 * {@hide} 1630 */ 1631 @Deprecated 1632 public static final String AIRPLANE_MODE_TOGGLEABLE_RADIOS = 1633 Global.AIRPLANE_MODE_TOGGLEABLE_RADIOS; 1634 1635 /** 1636 * @deprecated Use {@link android.provider.Settings.Global#WIFI_SLEEP_POLICY} instead 1637 */ 1638 @Deprecated 1639 public static final String WIFI_SLEEP_POLICY = Global.WIFI_SLEEP_POLICY; 1640 1641 /** 1642 * @deprecated Use {@link android.provider.Settings.Global#WIFI_SLEEP_POLICY_DEFAULT} instead 1643 */ 1644 @Deprecated 1645 public static final int WIFI_SLEEP_POLICY_DEFAULT = Global.WIFI_SLEEP_POLICY_DEFAULT; 1646 1647 /** 1648 * @deprecated Use {@link android.provider.Settings.Global#WIFI_SLEEP_POLICY_NEVER_WHILE_PLUGGED} instead 1649 */ 1650 @Deprecated 1651 public static final int WIFI_SLEEP_POLICY_NEVER_WHILE_PLUGGED = 1652 Global.WIFI_SLEEP_POLICY_NEVER_WHILE_PLUGGED; 1653 1654 /** 1655 * @deprecated Use {@link android.provider.Settings.Global#WIFI_SLEEP_POLICY_NEVER} instead 1656 */ 1657 @Deprecated 1658 public static final int WIFI_SLEEP_POLICY_NEVER = Global.WIFI_SLEEP_POLICY_NEVER; 1659 1660 /** 1661 * @deprecated Use {@link android.provider.Settings.Global#MODE_RINGER} instead 1662 */ 1663 @Deprecated 1664 public static final String MODE_RINGER = Global.MODE_RINGER; 1665 1666 /** 1667 * Whether to use static IP and other static network attributes. 1668 * <p> 1669 * Set to 1 for true and 0 for false. 1670 * 1671 * @deprecated Use {@link WifiManager} instead 1672 */ 1673 @Deprecated 1674 public static final String WIFI_USE_STATIC_IP = "wifi_use_static_ip"; 1675 1676 /** 1677 * The static IP address. 1678 * <p> 1679 * Example: "192.168.1.51" 1680 * 1681 * @deprecated Use {@link WifiManager} instead 1682 */ 1683 @Deprecated 1684 public static final String WIFI_STATIC_IP = "wifi_static_ip"; 1685 1686 /** 1687 * If using static IP, the gateway's IP address. 1688 * <p> 1689 * Example: "192.168.1.1" 1690 * 1691 * @deprecated Use {@link WifiManager} instead 1692 */ 1693 @Deprecated 1694 public static final String WIFI_STATIC_GATEWAY = "wifi_static_gateway"; 1695 1696 /** 1697 * If using static IP, the net mask. 1698 * <p> 1699 * Example: "255.255.255.0" 1700 * 1701 * @deprecated Use {@link WifiManager} instead 1702 */ 1703 @Deprecated 1704 public static final String WIFI_STATIC_NETMASK = "wifi_static_netmask"; 1705 1706 /** 1707 * If using static IP, the primary DNS's IP address. 1708 * <p> 1709 * Example: "192.168.1.1" 1710 * 1711 * @deprecated Use {@link WifiManager} instead 1712 */ 1713 @Deprecated 1714 public static final String WIFI_STATIC_DNS1 = "wifi_static_dns1"; 1715 1716 /** 1717 * If using static IP, the secondary DNS's IP address. 1718 * <p> 1719 * Example: "192.168.1.2" 1720 * 1721 * @deprecated Use {@link WifiManager} instead 1722 */ 1723 @Deprecated 1724 public static final String WIFI_STATIC_DNS2 = "wifi_static_dns2"; 1725 1726 1727 /** 1728 * Determines whether remote devices may discover and/or connect to 1729 * this device. 1730 * <P>Type: INT</P> 1731 * 2 -- discoverable and connectable 1732 * 1 -- connectable but not discoverable 1733 * 0 -- neither connectable nor discoverable 1734 */ 1735 public static final String BLUETOOTH_DISCOVERABILITY = 1736 "bluetooth_discoverability"; 1737 1738 /** 1739 * Bluetooth discoverability timeout. If this value is nonzero, then 1740 * Bluetooth becomes discoverable for a certain number of seconds, 1741 * after which is becomes simply connectable. The value is in seconds. 1742 */ 1743 public static final String BLUETOOTH_DISCOVERABILITY_TIMEOUT = 1744 "bluetooth_discoverability_timeout"; 1745 1746 /** 1747 * @deprecated Use {@link android.provider.Settings.Secure#LOCK_PATTERN_ENABLED} 1748 * instead 1749 */ 1750 @Deprecated 1751 public static final String LOCK_PATTERN_ENABLED = Secure.LOCK_PATTERN_ENABLED; 1752 1753 /** 1754 * @deprecated Use {@link android.provider.Settings.Secure#LOCK_PATTERN_VISIBLE} 1755 * instead 1756 */ 1757 @Deprecated 1758 public static final String LOCK_PATTERN_VISIBLE = "lock_pattern_visible_pattern"; 1759 1760 /** 1761 * @deprecated Use 1762 * {@link android.provider.Settings.Secure#LOCK_PATTERN_TACTILE_FEEDBACK_ENABLED} 1763 * instead 1764 */ 1765 @Deprecated 1766 public static final String LOCK_PATTERN_TACTILE_FEEDBACK_ENABLED = 1767 "lock_pattern_tactile_feedback_enabled"; 1768 1769 1770 /** 1771 * A formatted string of the next alarm that is set, or the empty string 1772 * if there is no alarm set. 1773 */ 1774 public static final String NEXT_ALARM_FORMATTED = "next_alarm_formatted"; 1775 1776 /** 1777 * Scaling factor for fonts, float. 1778 */ 1779 public static final String FONT_SCALE = "font_scale"; 1780 1781 /** 1782 * Name of an application package to be debugged. 1783 * 1784 * @deprecated Use {@link Global#DEBUG_APP} instead 1785 */ 1786 @Deprecated 1787 public static final String DEBUG_APP = Global.DEBUG_APP; 1788 1789 /** 1790 * If 1, when launching DEBUG_APP it will wait for the debugger before 1791 * starting user code. If 0, it will run normally. 1792 * 1793 * @deprecated Use {@link Global#WAIT_FOR_DEBUGGER} instead 1794 */ 1795 @Deprecated 1796 public static final String WAIT_FOR_DEBUGGER = Global.WAIT_FOR_DEBUGGER; 1797 1798 /** 1799 * Whether or not to dim the screen. 0=no 1=yes 1800 * @deprecated This setting is no longer used. 1801 */ 1802 @Deprecated 1803 public static final String DIM_SCREEN = "dim_screen"; 1804 1805 /** 1806 * The timeout before the screen turns off. 1807 */ 1808 public static final String SCREEN_OFF_TIMEOUT = "screen_off_timeout"; 1809 1810 /** 1811 * The screen backlight brightness between 0 and 255. 1812 */ 1813 public static final String SCREEN_BRIGHTNESS = "screen_brightness"; 1814 1815 /** 1816 * Control whether to enable automatic brightness mode. 1817 */ 1818 public static final String SCREEN_BRIGHTNESS_MODE = "screen_brightness_mode"; 1819 1820 /** 1821 * Adjustment to auto-brightness to make it generally more (>0.0 <1.0) 1822 * or less (<0.0 >-1.0) bright. 1823 * @hide 1824 */ 1825 public static final String SCREEN_AUTO_BRIGHTNESS_ADJ = "screen_auto_brightness_adj"; 1826 1827 /** 1828 * SCREEN_BRIGHTNESS_MODE value for manual mode. 1829 */ 1830 public static final int SCREEN_BRIGHTNESS_MODE_MANUAL = 0; 1831 1832 /** 1833 * SCREEN_BRIGHTNESS_MODE value for automatic mode. 1834 */ 1835 public static final int SCREEN_BRIGHTNESS_MODE_AUTOMATIC = 1; 1836 1837 /** 1838 * Control whether the process CPU usage meter should be shown. 1839 * 1840 * @deprecated Use {@link Global#SHOW_PROCESSES} instead 1841 */ 1842 @Deprecated 1843 public static final String SHOW_PROCESSES = Global.SHOW_PROCESSES; 1844 1845 /** 1846 * If 1, the activity manager will aggressively finish activities and 1847 * processes as soon as they are no longer needed. If 0, the normal 1848 * extended lifetime is used. 1849 * 1850 * @deprecated Use {@link Global#ALWAYS_FINISH_ACTIVITIES} instead 1851 */ 1852 @Deprecated 1853 public static final String ALWAYS_FINISH_ACTIVITIES = Global.ALWAYS_FINISH_ACTIVITIES; 1854 1855 /** 1856 * Determines which streams are affected by ringer mode changes. The 1857 * stream type's bit should be set to 1 if it should be muted when going 1858 * into an inaudible ringer mode. 1859 */ 1860 public static final String MODE_RINGER_STREAMS_AFFECTED = "mode_ringer_streams_affected"; 1861 1862 /** 1863 * Determines which streams are affected by mute. The 1864 * stream type's bit should be set to 1 if it should be muted when a mute request 1865 * is received. 1866 */ 1867 public static final String MUTE_STREAMS_AFFECTED = "mute_streams_affected"; 1868 1869 /** 1870 * Whether vibrate is on for different events. This is used internally, 1871 * changing this value will not change the vibrate. See AudioManager. 1872 */ 1873 public static final String VIBRATE_ON = "vibrate_on"; 1874 1875 /** 1876 * If 1, redirects the system vibrator to all currently attached input devices 1877 * that support vibration. If there are no such input devices, then the system 1878 * vibrator is used instead. 1879 * If 0, does not register the system vibrator. 1880 * 1881 * This setting is mainly intended to provide a compatibility mechanism for 1882 * applications that only know about the system vibrator and do not use the 1883 * input device vibrator API. 1884 * 1885 * @hide 1886 */ 1887 public static final String VIBRATE_INPUT_DEVICES = "vibrate_input_devices"; 1888 1889 /** 1890 * Ringer volume. This is used internally, changing this value will not 1891 * change the volume. See AudioManager. 1892 */ 1893 public static final String VOLUME_RING = "volume_ring"; 1894 1895 /** 1896 * System/notifications volume. This is used internally, changing this 1897 * value will not change the volume. See AudioManager. 1898 */ 1899 public static final String VOLUME_SYSTEM = "volume_system"; 1900 1901 /** 1902 * Voice call volume. This is used internally, changing this value will 1903 * not change the volume. See AudioManager. 1904 */ 1905 public static final String VOLUME_VOICE = "volume_voice"; 1906 1907 /** 1908 * Music/media/gaming volume. This is used internally, changing this 1909 * value will not change the volume. See AudioManager. 1910 */ 1911 public static final String VOLUME_MUSIC = "volume_music"; 1912 1913 /** 1914 * Alarm volume. This is used internally, changing this 1915 * value will not change the volume. See AudioManager. 1916 */ 1917 public static final String VOLUME_ALARM = "volume_alarm"; 1918 1919 /** 1920 * Notification volume. This is used internally, changing this 1921 * value will not change the volume. See AudioManager. 1922 */ 1923 public static final String VOLUME_NOTIFICATION = "volume_notification"; 1924 1925 /** 1926 * Bluetooth Headset volume. This is used internally, changing this value will 1927 * not change the volume. See AudioManager. 1928 */ 1929 public static final String VOLUME_BLUETOOTH_SCO = "volume_bluetooth_sco"; 1930 1931 /** 1932 * Master volume (float in the range 0.0f to 1.0f). 1933 * @hide 1934 */ 1935 public static final String VOLUME_MASTER = "volume_master"; 1936 1937 /** 1938 * Master volume mute (int 1 = mute, 0 = not muted). 1939 * 1940 * @hide 1941 */ 1942 public static final String VOLUME_MASTER_MUTE = "volume_master_mute"; 1943 1944 /** 1945 * Whether the notifications should use the ring volume (value of 1) or 1946 * a separate notification volume (value of 0). In most cases, users 1947 * will have this enabled so the notification and ringer volumes will be 1948 * the same. However, power users can disable this and use the separate 1949 * notification volume control. 1950 * <p> 1951 * Note: This is a one-off setting that will be removed in the future 1952 * when there is profile support. For this reason, it is kept hidden 1953 * from the public APIs. 1954 * 1955 * @hide 1956 * @deprecated 1957 */ 1958 @Deprecated 1959 public static final String NOTIFICATIONS_USE_RING_VOLUME = 1960 "notifications_use_ring_volume"; 1961 1962 /** 1963 * Whether silent mode should allow vibration feedback. This is used 1964 * internally in AudioService and the Sound settings activity to 1965 * coordinate decoupling of vibrate and silent modes. This setting 1966 * will likely be removed in a future release with support for 1967 * audio/vibe feedback profiles. 1968 * 1969 * Not used anymore. On devices with vibrator, the user explicitly selects 1970 * silent or vibrate mode. 1971 * Kept for use by legacy database upgrade code in DatabaseHelper. 1972 * @hide 1973 */ 1974 public static final String VIBRATE_IN_SILENT = "vibrate_in_silent"; 1975 1976 /** 1977 * The mapping of stream type (integer) to its setting. 1978 */ 1979 public static final String[] VOLUME_SETTINGS = { 1980 VOLUME_VOICE, VOLUME_SYSTEM, VOLUME_RING, VOLUME_MUSIC, 1981 VOLUME_ALARM, VOLUME_NOTIFICATION, VOLUME_BLUETOOTH_SCO 1982 }; 1983 1984 /** 1985 * Appended to various volume related settings to record the previous 1986 * values before they the settings were affected by a silent/vibrate 1987 * ringer mode change. 1988 */ 1989 public static final String APPEND_FOR_LAST_AUDIBLE = "_last_audible"; 1990 1991 /** 1992 * Persistent store for the system-wide default ringtone URI. 1993 * <p> 1994 * If you need to play the default ringtone at any given time, it is recommended 1995 * you give {@link #DEFAULT_RINGTONE_URI} to the media player. It will resolve 1996 * to the set default ringtone at the time of playing. 1997 * 1998 * @see #DEFAULT_RINGTONE_URI 1999 */ 2000 public static final String RINGTONE = "ringtone"; 2001 2002 /** 2003 * A {@link Uri} that will point to the current default ringtone at any 2004 * given time. 2005 * <p> 2006 * If the current default ringtone is in the DRM provider and the caller 2007 * does not have permission, the exception will be a 2008 * FileNotFoundException. 2009 */ 2010 public static final Uri DEFAULT_RINGTONE_URI = getUriFor(RINGTONE); 2011 2012 /** 2013 * Persistent store for the system-wide default notification sound. 2014 * 2015 * @see #RINGTONE 2016 * @see #DEFAULT_NOTIFICATION_URI 2017 */ 2018 public static final String NOTIFICATION_SOUND = "notification_sound"; 2019 2020 /** 2021 * A {@link Uri} that will point to the current default notification 2022 * sound at any given time. 2023 * 2024 * @see #DEFAULT_RINGTONE_URI 2025 */ 2026 public static final Uri DEFAULT_NOTIFICATION_URI = getUriFor(NOTIFICATION_SOUND); 2027 2028 /** 2029 * Persistent store for the system-wide default alarm alert. 2030 * 2031 * @see #RINGTONE 2032 * @see #DEFAULT_ALARM_ALERT_URI 2033 */ 2034 public static final String ALARM_ALERT = "alarm_alert"; 2035 2036 /** 2037 * A {@link Uri} that will point to the current default alarm alert at 2038 * any given time. 2039 * 2040 * @see #DEFAULT_ALARM_ALERT_URI 2041 */ 2042 public static final Uri DEFAULT_ALARM_ALERT_URI = getUriFor(ALARM_ALERT); 2043 2044 /** 2045 * Persistent store for the system default media button event receiver. 2046 * 2047 * @hide 2048 */ 2049 public static final String MEDIA_BUTTON_RECEIVER = "media_button_receiver"; 2050 2051 /** 2052 * Setting to enable Auto Replace (AutoText) in text editors. 1 = On, 0 = Off 2053 */ 2054 public static final String TEXT_AUTO_REPLACE = "auto_replace"; 2055 2056 /** 2057 * Setting to enable Auto Caps in text editors. 1 = On, 0 = Off 2058 */ 2059 public static final String TEXT_AUTO_CAPS = "auto_caps"; 2060 2061 /** 2062 * Setting to enable Auto Punctuate in text editors. 1 = On, 0 = Off. This 2063 * feature converts two spaces to a "." and space. 2064 */ 2065 public static final String TEXT_AUTO_PUNCTUATE = "auto_punctuate"; 2066 2067 /** 2068 * Setting to showing password characters in text editors. 1 = On, 0 = Off 2069 */ 2070 public static final String TEXT_SHOW_PASSWORD = "show_password"; 2071 2072 public static final String SHOW_GTALK_SERVICE_STATUS = 2073 "SHOW_GTALK_SERVICE_STATUS"; 2074 2075 /** 2076 * Name of activity to use for wallpaper on the home screen. 2077 * 2078 * @deprecated Use {@link WallpaperManager} instead. 2079 */ 2080 @Deprecated 2081 public static final String WALLPAPER_ACTIVITY = "wallpaper_activity"; 2082 2083 /** 2084 * @deprecated Use {@link android.provider.Settings.Global#AUTO_TIME} 2085 * instead 2086 */ 2087 @Deprecated 2088 public static final String AUTO_TIME = Global.AUTO_TIME; 2089 2090 /** 2091 * @deprecated Use {@link android.provider.Settings.Global#AUTO_TIME_ZONE} 2092 * instead 2093 */ 2094 @Deprecated 2095 public static final String AUTO_TIME_ZONE = Global.AUTO_TIME_ZONE; 2096 2097 /** 2098 * Display times as 12 or 24 hours 2099 * 12 2100 * 24 2101 */ 2102 public static final String TIME_12_24 = "time_12_24"; 2103 2104 /** 2105 * Date format string 2106 * mm/dd/yyyy 2107 * dd/mm/yyyy 2108 * yyyy/mm/dd 2109 */ 2110 public static final String DATE_FORMAT = "date_format"; 2111 2112 /** 2113 * Whether the setup wizard has been run before (on first boot), or if 2114 * it still needs to be run. 2115 * 2116 * nonzero = it has been run in the past 2117 * 0 = it has not been run in the past 2118 */ 2119 public static final String SETUP_WIZARD_HAS_RUN = "setup_wizard_has_run"; 2120 2121 /** 2122 * Scaling factor for normal window animations. Setting to 0 will disable window 2123 * animations. 2124 * 2125 * @deprecated Use {@link Global#WINDOW_ANIMATION_SCALE} instead 2126 */ 2127 @Deprecated 2128 public static final String WINDOW_ANIMATION_SCALE = Global.WINDOW_ANIMATION_SCALE; 2129 2130 /** 2131 * Scaling factor for activity transition animations. Setting to 0 will disable window 2132 * animations. 2133 * 2134 * @deprecated Use {@link Global#TRANSITION_ANIMATION_SCALE} instead 2135 */ 2136 @Deprecated 2137 public static final String TRANSITION_ANIMATION_SCALE = Global.TRANSITION_ANIMATION_SCALE; 2138 2139 /** 2140 * Scaling factor for Animator-based animations. This affects both the start delay and 2141 * duration of all such animations. Setting to 0 will cause animations to end immediately. 2142 * The default value is 1. 2143 * 2144 * @deprecated Use {@link Global#ANIMATOR_DURATION_SCALE} instead 2145 */ 2146 @Deprecated 2147 public static final String ANIMATOR_DURATION_SCALE = Global.ANIMATOR_DURATION_SCALE; 2148 2149 /** 2150 * Control whether the accelerometer will be used to change screen 2151 * orientation. If 0, it will not be used unless explicitly requested 2152 * by the application; if 1, it will be used by default unless explicitly 2153 * disabled by the application. 2154 */ 2155 public static final String ACCELEROMETER_ROTATION = "accelerometer_rotation"; 2156 2157 /** 2158 * Default screen rotation when no other policy applies. 2159 * When {@link #ACCELEROMETER_ROTATION} is zero and no on-screen Activity expresses a 2160 * preference, this rotation value will be used. Must be one of the 2161 * {@link android.view.Surface#ROTATION_0 Surface rotation constants}. 2162 * 2163 * @see Display#getRotation 2164 */ 2165 public static final String USER_ROTATION = "user_rotation"; 2166 2167 /** 2168 * Control whether the rotation lock toggle in the System UI should be hidden. 2169 * Typically this is done for accessibility purposes to make it harder for 2170 * the user to accidentally toggle the rotation lock while the display rotation 2171 * has been locked for accessibility. 2172 * 2173 * If 0, then rotation lock toggle is not hidden for accessibility (although it may be 2174 * unavailable for other reasons). If 1, then the rotation lock toggle is hidden. 2175 * 2176 * @hide 2177 */ 2178 public static final String HIDE_ROTATION_LOCK_TOGGLE_FOR_ACCESSIBILITY = 2179 "hide_rotation_lock_toggle_for_accessibility"; 2180 2181 /** 2182 * Whether the phone vibrates when it is ringing due to an incoming call. This will 2183 * be used by Phone and Setting apps; it shouldn't affect other apps. 2184 * The value is boolean (1 or 0). 2185 * 2186 * Note: this is not same as "vibrate on ring", which had been available until ICS. 2187 * It was about AudioManager's setting and thus affected all the applications which 2188 * relied on the setting, while this is purely about the vibration setting for incoming 2189 * calls. 2190 * 2191 * @hide 2192 */ 2193 public static final String VIBRATE_WHEN_RINGING = "vibrate_when_ringing"; 2194 2195 /** 2196 * Whether the audible DTMF tones are played by the dialer when dialing. The value is 2197 * boolean (1 or 0). 2198 */ 2199 public static final String DTMF_TONE_WHEN_DIALING = "dtmf_tone"; 2200 2201 /** 2202 * CDMA only settings 2203 * DTMF tone type played by the dialer when dialing. 2204 * 0 = Normal 2205 * 1 = Long 2206 * @hide 2207 */ 2208 public static final String DTMF_TONE_TYPE_WHEN_DIALING = "dtmf_tone_type"; 2209 2210 /** 2211 * Whether the hearing aid is enabled. The value is 2212 * boolean (1 or 0). 2213 * @hide 2214 */ 2215 public static final String HEARING_AID = "hearing_aid"; 2216 2217 /** 2218 * CDMA only settings 2219 * TTY Mode 2220 * 0 = OFF 2221 * 1 = FULL 2222 * 2 = VCO 2223 * 3 = HCO 2224 * @hide 2225 */ 2226 public static final String TTY_MODE = "tty_mode"; 2227 2228 /** 2229 * Whether the sounds effects (key clicks, lid open ...) are enabled. The value is 2230 * boolean (1 or 0). 2231 */ 2232 public static final String SOUND_EFFECTS_ENABLED = "sound_effects_enabled"; 2233 2234 /** 2235 * Whether the haptic feedback (long presses, ...) are enabled. The value is 2236 * boolean (1 or 0). 2237 */ 2238 public static final String HAPTIC_FEEDBACK_ENABLED = "haptic_feedback_enabled"; 2239 2240 /** 2241 * @deprecated Each application that shows web suggestions should have its own 2242 * setting for this. 2243 */ 2244 @Deprecated 2245 public static final String SHOW_WEB_SUGGESTIONS = "show_web_suggestions"; 2246 2247 /** 2248 * Whether the notification LED should repeatedly flash when a notification is 2249 * pending. The value is boolean (1 or 0). 2250 * @hide 2251 */ 2252 public static final String NOTIFICATION_LIGHT_PULSE = "notification_light_pulse"; 2253 2254 /** 2255 * Show pointer location on screen? 2256 * 0 = no 2257 * 1 = yes 2258 * @hide 2259 */ 2260 public static final String POINTER_LOCATION = "pointer_location"; 2261 2262 /** 2263 * Show touch positions on screen? 2264 * 0 = no 2265 * 1 = yes 2266 * @hide 2267 */ 2268 public static final String SHOW_TOUCHES = "show_touches"; 2269 2270 /** 2271 * Log raw orientation data from {@link WindowOrientationListener} for use with the 2272 * orientationplot.py tool. 2273 * 0 = no 2274 * 1 = yes 2275 * @hide 2276 */ 2277 public static final String WINDOW_ORIENTATION_LISTENER_LOG = 2278 "window_orientation_listener_log"; 2279 2280 /** 2281 * @deprecated Use {@link android.provider.Settings.Global#POWER_SOUNDS_ENABLED} 2282 * instead 2283 * @hide 2284 */ 2285 @Deprecated 2286 public static final String POWER_SOUNDS_ENABLED = Global.POWER_SOUNDS_ENABLED; 2287 2288 /** 2289 * @deprecated Use {@link android.provider.Settings.Global#DOCK_SOUNDS_ENABLED} 2290 * instead 2291 * @hide 2292 */ 2293 @Deprecated 2294 public static final String DOCK_SOUNDS_ENABLED = Global.DOCK_SOUNDS_ENABLED; 2295 2296 /** 2297 * Whether to play sounds when the keyguard is shown and dismissed. 2298 * @hide 2299 */ 2300 public static final String LOCKSCREEN_SOUNDS_ENABLED = "lockscreen_sounds_enabled"; 2301 2302 /** 2303 * Whether the lockscreen should be completely disabled. 2304 * @hide 2305 */ 2306 public static final String LOCKSCREEN_DISABLED = "lockscreen.disabled"; 2307 2308 /** 2309 * @deprecated Use {@link android.provider.Settings.Global#LOW_BATTERY_SOUND} 2310 * instead 2311 * @hide 2312 */ 2313 @Deprecated 2314 public static final String LOW_BATTERY_SOUND = Global.LOW_BATTERY_SOUND; 2315 2316 /** 2317 * @deprecated Use {@link android.provider.Settings.Global#DESK_DOCK_SOUND} 2318 * instead 2319 * @hide 2320 */ 2321 @Deprecated 2322 public static final String DESK_DOCK_SOUND = Global.DESK_DOCK_SOUND; 2323 2324 /** 2325 * @deprecated Use {@link android.provider.Settings.Global#DESK_UNDOCK_SOUND} 2326 * instead 2327 * @hide 2328 */ 2329 @Deprecated 2330 public static final String DESK_UNDOCK_SOUND = Global.DESK_UNDOCK_SOUND; 2331 2332 /** 2333 * @deprecated Use {@link android.provider.Settings.Global#CAR_DOCK_SOUND} 2334 * instead 2335 * @hide 2336 */ 2337 @Deprecated 2338 public static final String CAR_DOCK_SOUND = Global.CAR_DOCK_SOUND; 2339 2340 /** 2341 * @deprecated Use {@link android.provider.Settings.Global#CAR_UNDOCK_SOUND} 2342 * instead 2343 * @hide 2344 */ 2345 @Deprecated 2346 public static final String CAR_UNDOCK_SOUND = Global.CAR_UNDOCK_SOUND; 2347 2348 /** 2349 * @deprecated Use {@link android.provider.Settings.Global#LOCK_SOUND} 2350 * instead 2351 * @hide 2352 */ 2353 @Deprecated 2354 public static final String LOCK_SOUND = Global.LOCK_SOUND; 2355 2356 /** 2357 * @deprecated Use {@link android.provider.Settings.Global#UNLOCK_SOUND} 2358 * instead 2359 * @hide 2360 */ 2361 @Deprecated 2362 public static final String UNLOCK_SOUND = Global.UNLOCK_SOUND; 2363 2364 /** 2365 * Receive incoming SIP calls? 2366 * 0 = no 2367 * 1 = yes 2368 * @hide 2369 */ 2370 public static final String SIP_RECEIVE_CALLS = "sip_receive_calls"; 2371 2372 /** 2373 * Call Preference String. 2374 * "SIP_ALWAYS" : Always use SIP with network access 2375 * "SIP_ADDRESS_ONLY" : Only if destination is a SIP address 2376 * "SIP_ASK_ME_EACH_TIME" : Always ask me each time 2377 * @hide 2378 */ 2379 public static final String SIP_CALL_OPTIONS = "sip_call_options"; 2380 2381 /** 2382 * One of the sip call options: Always use SIP with network access. 2383 * @hide 2384 */ 2385 public static final String SIP_ALWAYS = "SIP_ALWAYS"; 2386 2387 /** 2388 * One of the sip call options: Only if destination is a SIP address. 2389 * @hide 2390 */ 2391 public static final String SIP_ADDRESS_ONLY = "SIP_ADDRESS_ONLY"; 2392 2393 /** 2394 * One of the sip call options: Always ask me each time. 2395 * @hide 2396 */ 2397 public static final String SIP_ASK_ME_EACH_TIME = "SIP_ASK_ME_EACH_TIME"; 2398 2399 /** 2400 * Pointer speed setting. 2401 * This is an integer value in a range between -7 and +7, so there are 15 possible values. 2402 * -7 = slowest 2403 * 0 = default speed 2404 * +7 = fastest 2405 * @hide 2406 */ 2407 public static final String POINTER_SPEED = "pointer_speed"; 2408 2409 /** 2410 * I am the lolrus. 2411 * <p> 2412 * Nonzero values indicate that the user has a bukkit. 2413 * Backward-compatible with <code>PrefGetPreference(prefAllowEasterEggs)</code>. 2414 * @hide 2415 */ 2416 public static final String EGG_MODE = "egg_mode"; 2417 2418 /** 2419 * Settings to backup. This is here so that it's in the same place as the settings 2420 * keys and easy to update. 2421 * 2422 * NOTE: Settings are backed up and restored in the order they appear 2423 * in this array. If you have one setting depending on another, 2424 * make sure that they are ordered appropriately. 2425 * 2426 * @hide 2427 */ 2428 public static final String[] SETTINGS_TO_BACKUP = { 2429 STAY_ON_WHILE_PLUGGED_IN, // moved to global 2430 WIFI_USE_STATIC_IP, 2431 WIFI_STATIC_IP, 2432 WIFI_STATIC_GATEWAY, 2433 WIFI_STATIC_NETMASK, 2434 WIFI_STATIC_DNS1, 2435 WIFI_STATIC_DNS2, 2436 BLUETOOTH_DISCOVERABILITY, 2437 BLUETOOTH_DISCOVERABILITY_TIMEOUT, 2438 DIM_SCREEN, 2439 SCREEN_OFF_TIMEOUT, 2440 SCREEN_BRIGHTNESS, 2441 SCREEN_BRIGHTNESS_MODE, 2442 SCREEN_AUTO_BRIGHTNESS_ADJ, 2443 VIBRATE_INPUT_DEVICES, 2444 MODE_RINGER_STREAMS_AFFECTED, 2445 VOLUME_VOICE, 2446 VOLUME_SYSTEM, 2447 VOLUME_RING, 2448 VOLUME_MUSIC, 2449 VOLUME_ALARM, 2450 VOLUME_NOTIFICATION, 2451 VOLUME_BLUETOOTH_SCO, 2452 VOLUME_VOICE + APPEND_FOR_LAST_AUDIBLE, 2453 VOLUME_SYSTEM + APPEND_FOR_LAST_AUDIBLE, 2454 VOLUME_RING + APPEND_FOR_LAST_AUDIBLE, 2455 VOLUME_MUSIC + APPEND_FOR_LAST_AUDIBLE, 2456 VOLUME_ALARM + APPEND_FOR_LAST_AUDIBLE, 2457 VOLUME_NOTIFICATION + APPEND_FOR_LAST_AUDIBLE, 2458 VOLUME_BLUETOOTH_SCO + APPEND_FOR_LAST_AUDIBLE, 2459 TEXT_AUTO_REPLACE, 2460 TEXT_AUTO_CAPS, 2461 TEXT_AUTO_PUNCTUATE, 2462 TEXT_SHOW_PASSWORD, 2463 AUTO_TIME, // moved to global 2464 AUTO_TIME_ZONE, // moved to global 2465 TIME_12_24, 2466 DATE_FORMAT, 2467 DTMF_TONE_WHEN_DIALING, 2468 DTMF_TONE_TYPE_WHEN_DIALING, 2469 HEARING_AID, 2470 TTY_MODE, 2471 SOUND_EFFECTS_ENABLED, 2472 HAPTIC_FEEDBACK_ENABLED, 2473 POWER_SOUNDS_ENABLED, // moved to global 2474 DOCK_SOUNDS_ENABLED, // moved to global 2475 LOCKSCREEN_SOUNDS_ENABLED, 2476 SHOW_WEB_SUGGESTIONS, 2477 NOTIFICATION_LIGHT_PULSE, 2478 SIP_CALL_OPTIONS, 2479 SIP_RECEIVE_CALLS, 2480 POINTER_SPEED, 2481 VIBRATE_WHEN_RINGING, 2482 RINGTONE, 2483 NOTIFICATION_SOUND 2484 }; 2485 2486 // Settings moved to Settings.Secure 2487 2488 /** 2489 * @deprecated Use {@link android.provider.Settings.Global#ADB_ENABLED} 2490 * instead 2491 */ 2492 @Deprecated 2493 public static final String ADB_ENABLED = Global.ADB_ENABLED; 2494 2495 /** 2496 * @deprecated Use {@link android.provider.Settings.Secure#ANDROID_ID} instead 2497 */ 2498 @Deprecated 2499 public static final String ANDROID_ID = Secure.ANDROID_ID; 2500 2501 /** 2502 * @deprecated Use {@link android.provider.Settings.Global#BLUETOOTH_ON} instead 2503 */ 2504 @Deprecated 2505 public static final String BLUETOOTH_ON = Global.BLUETOOTH_ON; 2506 2507 /** 2508 * @deprecated Use {@link android.provider.Settings.Global#DATA_ROAMING} instead 2509 */ 2510 @Deprecated 2511 public static final String DATA_ROAMING = Global.DATA_ROAMING; 2512 2513 /** 2514 * @deprecated Use {@link android.provider.Settings.Global#DEVICE_PROVISIONED} instead 2515 */ 2516 @Deprecated 2517 public static final String DEVICE_PROVISIONED = Global.DEVICE_PROVISIONED; 2518 2519 /** 2520 * @deprecated Use {@link android.provider.Settings.Global#HTTP_PROXY} instead 2521 */ 2522 @Deprecated 2523 public static final String HTTP_PROXY = Global.HTTP_PROXY; 2524 2525 /** 2526 * @deprecated Use {@link android.provider.Settings.Global#INSTALL_NON_MARKET_APPS} instead 2527 */ 2528 @Deprecated 2529 public static final String INSTALL_NON_MARKET_APPS = Global.INSTALL_NON_MARKET_APPS; 2530 2531 /** 2532 * @deprecated Use {@link android.provider.Settings.Secure#LOCATION_PROVIDERS_ALLOWED} 2533 * instead 2534 */ 2535 @Deprecated 2536 public static final String LOCATION_PROVIDERS_ALLOWED = Secure.LOCATION_PROVIDERS_ALLOWED; 2537 2538 /** 2539 * @deprecated Use {@link android.provider.Settings.Secure#LOGGING_ID} instead 2540 */ 2541 @Deprecated 2542 public static final String LOGGING_ID = Secure.LOGGING_ID; 2543 2544 /** 2545 * @deprecated Use {@link android.provider.Settings.Global#NETWORK_PREFERENCE} instead 2546 */ 2547 @Deprecated 2548 public static final String NETWORK_PREFERENCE = Global.NETWORK_PREFERENCE; 2549 2550 /** 2551 * @deprecated Use {@link android.provider.Settings.Secure#PARENTAL_CONTROL_ENABLED} 2552 * instead 2553 */ 2554 @Deprecated 2555 public static final String PARENTAL_CONTROL_ENABLED = Secure.PARENTAL_CONTROL_ENABLED; 2556 2557 /** 2558 * @deprecated Use {@link android.provider.Settings.Secure#PARENTAL_CONTROL_LAST_UPDATE} 2559 * instead 2560 */ 2561 @Deprecated 2562 public static final String PARENTAL_CONTROL_LAST_UPDATE = Secure.PARENTAL_CONTROL_LAST_UPDATE; 2563 2564 /** 2565 * @deprecated Use {@link android.provider.Settings.Secure#PARENTAL_CONTROL_REDIRECT_URL} 2566 * instead 2567 */ 2568 @Deprecated 2569 public static final String PARENTAL_CONTROL_REDIRECT_URL = 2570 Secure.PARENTAL_CONTROL_REDIRECT_URL; 2571 2572 /** 2573 * @deprecated Use {@link android.provider.Settings.Secure#SETTINGS_CLASSNAME} instead 2574 */ 2575 @Deprecated 2576 public static final String SETTINGS_CLASSNAME = Secure.SETTINGS_CLASSNAME; 2577 2578 /** 2579 * @deprecated Use {@link android.provider.Settings.Global#USB_MASS_STORAGE_ENABLED} instead 2580 */ 2581 @Deprecated 2582 public static final String USB_MASS_STORAGE_ENABLED = Global.USB_MASS_STORAGE_ENABLED; 2583 2584 /** 2585 * @deprecated Use {@link android.provider.Settings.Global#USE_GOOGLE_MAIL} instead 2586 */ 2587 @Deprecated 2588 public static final String USE_GOOGLE_MAIL = Global.USE_GOOGLE_MAIL; 2589 2590 /** 2591 * @deprecated Use 2592 * {@link android.provider.Settings.Global#WIFI_MAX_DHCP_RETRY_COUNT} instead 2593 */ 2594 @Deprecated 2595 public static final String WIFI_MAX_DHCP_RETRY_COUNT = Global.WIFI_MAX_DHCP_RETRY_COUNT; 2596 2597 /** 2598 * @deprecated Use 2599 * {@link android.provider.Settings.Global#WIFI_MOBILE_DATA_TRANSITION_WAKELOCK_TIMEOUT_MS} instead 2600 */ 2601 @Deprecated 2602 public static final String WIFI_MOBILE_DATA_TRANSITION_WAKELOCK_TIMEOUT_MS = 2603 Global.WIFI_MOBILE_DATA_TRANSITION_WAKELOCK_TIMEOUT_MS; 2604 2605 /** 2606 * @deprecated Use 2607 * {@link android.provider.Settings.Global#WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON} instead 2608 */ 2609 @Deprecated 2610 public static final String WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON = 2611 Global.WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON; 2612 2613 /** 2614 * @deprecated Use 2615 * {@link android.provider.Settings.Global#WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY} instead 2616 */ 2617 @Deprecated 2618 public static final String WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY = 2619 Global.WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY; 2620 2621 /** 2622 * @deprecated Use {@link android.provider.Settings.Global#WIFI_NUM_OPEN_NETWORKS_KEPT} 2623 * instead 2624 */ 2625 @Deprecated 2626 public static final String WIFI_NUM_OPEN_NETWORKS_KEPT = Global.WIFI_NUM_OPEN_NETWORKS_KEPT; 2627 2628 /** 2629 * @deprecated Use {@link android.provider.Settings.Global#WIFI_ON} instead 2630 */ 2631 @Deprecated 2632 public static final String WIFI_ON = Global.WIFI_ON; 2633 2634 /** 2635 * @deprecated Use 2636 * {@link android.provider.Settings.Secure#WIFI_WATCHDOG_ACCEPTABLE_PACKET_LOSS_PERCENTAGE} 2637 * instead 2638 */ 2639 @Deprecated 2640 public static final String WIFI_WATCHDOG_ACCEPTABLE_PACKET_LOSS_PERCENTAGE = 2641 Secure.WIFI_WATCHDOG_ACCEPTABLE_PACKET_LOSS_PERCENTAGE; 2642 2643 /** 2644 * @deprecated Use {@link android.provider.Settings.Secure#WIFI_WATCHDOG_AP_COUNT} instead 2645 */ 2646 @Deprecated 2647 public static final String WIFI_WATCHDOG_AP_COUNT = Secure.WIFI_WATCHDOG_AP_COUNT; 2648 2649 /** 2650 * @deprecated Use 2651 * {@link android.provider.Settings.Secure#WIFI_WATCHDOG_BACKGROUND_CHECK_DELAY_MS} instead 2652 */ 2653 @Deprecated 2654 public static final String WIFI_WATCHDOG_BACKGROUND_CHECK_DELAY_MS = 2655 Secure.WIFI_WATCHDOG_BACKGROUND_CHECK_DELAY_MS; 2656 2657 /** 2658 * @deprecated Use 2659 * {@link android.provider.Settings.Secure#WIFI_WATCHDOG_BACKGROUND_CHECK_ENABLED} instead 2660 */ 2661 @Deprecated 2662 public static final String WIFI_WATCHDOG_BACKGROUND_CHECK_ENABLED = 2663 Secure.WIFI_WATCHDOG_BACKGROUND_CHECK_ENABLED; 2664 2665 /** 2666 * @deprecated Use 2667 * {@link android.provider.Settings.Secure#WIFI_WATCHDOG_BACKGROUND_CHECK_TIMEOUT_MS} 2668 * instead 2669 */ 2670 @Deprecated 2671 public static final String WIFI_WATCHDOG_BACKGROUND_CHECK_TIMEOUT_MS = 2672 Secure.WIFI_WATCHDOG_BACKGROUND_CHECK_TIMEOUT_MS; 2673 2674 /** 2675 * @deprecated Use 2676 * {@link android.provider.Settings.Secure#WIFI_WATCHDOG_INITIAL_IGNORED_PING_COUNT} instead 2677 */ 2678 @Deprecated 2679 public static final String WIFI_WATCHDOG_INITIAL_IGNORED_PING_COUNT = 2680 Secure.WIFI_WATCHDOG_INITIAL_IGNORED_PING_COUNT; 2681 2682 /** 2683 * @deprecated Use {@link android.provider.Settings.Secure#WIFI_WATCHDOG_MAX_AP_CHECKS} 2684 * instead 2685 */ 2686 @Deprecated 2687 public static final String WIFI_WATCHDOG_MAX_AP_CHECKS = Secure.WIFI_WATCHDOG_MAX_AP_CHECKS; 2688 2689 /** 2690 * @deprecated Use {@link android.provider.Settings.Global#WIFI_WATCHDOG_ON} instead 2691 */ 2692 @Deprecated 2693 public static final String WIFI_WATCHDOG_ON = Global.WIFI_WATCHDOG_ON; 2694 2695 /** 2696 * @deprecated Use {@link android.provider.Settings.Secure#WIFI_WATCHDOG_PING_COUNT} instead 2697 */ 2698 @Deprecated 2699 public static final String WIFI_WATCHDOG_PING_COUNT = Secure.WIFI_WATCHDOG_PING_COUNT; 2700 2701 /** 2702 * @deprecated Use {@link android.provider.Settings.Secure#WIFI_WATCHDOG_PING_DELAY_MS} 2703 * instead 2704 */ 2705 @Deprecated 2706 public static final String WIFI_WATCHDOG_PING_DELAY_MS = Secure.WIFI_WATCHDOG_PING_DELAY_MS; 2707 2708 /** 2709 * @deprecated Use {@link android.provider.Settings.Secure#WIFI_WATCHDOG_PING_TIMEOUT_MS} 2710 * instead 2711 */ 2712 @Deprecated 2713 public static final String WIFI_WATCHDOG_PING_TIMEOUT_MS = 2714 Secure.WIFI_WATCHDOG_PING_TIMEOUT_MS; 2715 } 2716 2717 /** 2718 * Secure system settings, containing system preferences that applications 2719 * can read but are not allowed to write. These are for preferences that 2720 * the user must explicitly modify through the system UI or specialized 2721 * APIs for those values, not modified directly by applications. 2722 */ 2723 public static final class Secure extends NameValueTable { 2724 public static final String SYS_PROP_SETTING_VERSION = "sys.settings_secure_version"; 2725 2726 /** 2727 * The content:// style URL for this table 2728 */ 2729 public static final Uri CONTENT_URI = 2730 Uri.parse("content://" + AUTHORITY + "/secure"); 2731 2732 // Populated lazily, guarded by class object: 2733 private static final NameValueCache sNameValueCache = new NameValueCache( 2734 SYS_PROP_SETTING_VERSION, 2735 CONTENT_URI, 2736 CALL_METHOD_GET_SECURE, 2737 CALL_METHOD_PUT_SECURE); 2738 2739 private static ILockSettings sLockSettings = null; 2740 2741 private static boolean sIsSystemProcess; 2742 private static final HashSet<String> MOVED_TO_LOCK_SETTINGS; 2743 private static final HashSet<String> MOVED_TO_GLOBAL; 2744 static { 2745 MOVED_TO_LOCK_SETTINGS = new HashSet<String>(3); 2746 MOVED_TO_LOCK_SETTINGS.add(Secure.LOCK_PATTERN_ENABLED); 2747 MOVED_TO_LOCK_SETTINGS.add(Secure.LOCK_PATTERN_VISIBLE); 2748 MOVED_TO_LOCK_SETTINGS.add(Secure.LOCK_PATTERN_TACTILE_FEEDBACK_ENABLED); 2749 2750 MOVED_TO_GLOBAL = new HashSet<String>(); 2751 MOVED_TO_GLOBAL.add(Settings.Global.ADB_ENABLED); 2752 MOVED_TO_GLOBAL.add(Settings.Global.ASSISTED_GPS_ENABLED); 2753 MOVED_TO_GLOBAL.add(Settings.Global.BLUETOOTH_ON); 2754 MOVED_TO_GLOBAL.add(Settings.Global.BUGREPORT_IN_POWER_MENU); 2755 MOVED_TO_GLOBAL.add(Settings.Global.CDMA_CELL_BROADCAST_SMS); 2756 MOVED_TO_GLOBAL.add(Settings.Global.CDMA_ROAMING_MODE); 2757 MOVED_TO_GLOBAL.add(Settings.Global.CDMA_SUBSCRIPTION_MODE); 2758 MOVED_TO_GLOBAL.add(Settings.Global.DATA_ACTIVITY_TIMEOUT_MOBILE); 2759 MOVED_TO_GLOBAL.add(Settings.Global.DATA_ACTIVITY_TIMEOUT_WIFI); 2760 MOVED_TO_GLOBAL.add(Settings.Global.DATA_ROAMING); 2761 MOVED_TO_GLOBAL.add(Settings.Global.DEVELOPMENT_SETTINGS_ENABLED); 2762 MOVED_TO_GLOBAL.add(Settings.Global.DEVICE_PROVISIONED); 2763 MOVED_TO_GLOBAL.add(Settings.Global.DISPLAY_DENSITY_FORCED); 2764 MOVED_TO_GLOBAL.add(Settings.Global.DISPLAY_SIZE_FORCED); 2765 MOVED_TO_GLOBAL.add(Settings.Global.DOWNLOAD_MAX_BYTES_OVER_MOBILE); 2766 MOVED_TO_GLOBAL.add(Settings.Global.DOWNLOAD_RECOMMENDED_MAX_BYTES_OVER_MOBILE); 2767 MOVED_TO_GLOBAL.add(Settings.Global.INSTALL_NON_MARKET_APPS); 2768 MOVED_TO_GLOBAL.add(Settings.Global.MOBILE_DATA); 2769 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_DEV_BUCKET_DURATION); 2770 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_DEV_DELETE_AGE); 2771 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_DEV_PERSIST_BYTES); 2772 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_DEV_ROTATE_AGE); 2773 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_ENABLED); 2774 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_GLOBAL_ALERT_BYTES); 2775 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_POLL_INTERVAL); 2776 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_REPORT_XT_OVER_DEV); 2777 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_SAMPLE_ENABLED); 2778 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_TIME_CACHE_MAX_AGE); 2779 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_UID_BUCKET_DURATION); 2780 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_UID_DELETE_AGE); 2781 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_UID_PERSIST_BYTES); 2782 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_UID_ROTATE_AGE); 2783 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_UID_TAG_BUCKET_DURATION); 2784 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_UID_TAG_DELETE_AGE); 2785 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_UID_TAG_PERSIST_BYTES); 2786 MOVED_TO_GLOBAL.add(Settings.Global.NETSTATS_UID_TAG_ROTATE_AGE); 2787 MOVED_TO_GLOBAL.add(Settings.Global.NETWORK_PREFERENCE); 2788 MOVED_TO_GLOBAL.add(Settings.Global.NITZ_UPDATE_DIFF); 2789 MOVED_TO_GLOBAL.add(Settings.Global.NITZ_UPDATE_SPACING); 2790 MOVED_TO_GLOBAL.add(Settings.Global.NTP_SERVER); 2791 MOVED_TO_GLOBAL.add(Settings.Global.NTP_TIMEOUT); 2792 MOVED_TO_GLOBAL.add(Settings.Global.PDP_WATCHDOG_ERROR_POLL_COUNT); 2793 MOVED_TO_GLOBAL.add(Settings.Global.PDP_WATCHDOG_LONG_POLL_INTERVAL_MS); 2794 MOVED_TO_GLOBAL.add(Settings.Global.PDP_WATCHDOG_MAX_PDP_RESET_FAIL_COUNT); 2795 MOVED_TO_GLOBAL.add(Settings.Global.PDP_WATCHDOG_POLL_INTERVAL_MS); 2796 MOVED_TO_GLOBAL.add(Settings.Global.PDP_WATCHDOG_TRIGGER_PACKET_COUNT); 2797 MOVED_TO_GLOBAL.add(Settings.Global.SAMPLING_PROFILER_MS); 2798 MOVED_TO_GLOBAL.add(Settings.Global.SETUP_PREPAID_DATA_SERVICE_URL); 2799 MOVED_TO_GLOBAL.add(Settings.Global.SETUP_PREPAID_DETECTION_REDIR_HOST); 2800 MOVED_TO_GLOBAL.add(Settings.Global.SETUP_PREPAID_DETECTION_TARGET_URL); 2801 MOVED_TO_GLOBAL.add(Settings.Global.TETHER_DUN_APN); 2802 MOVED_TO_GLOBAL.add(Settings.Global.TETHER_DUN_REQUIRED); 2803 MOVED_TO_GLOBAL.add(Settings.Global.TETHER_SUPPORTED); 2804 MOVED_TO_GLOBAL.add(Settings.Global.USB_MASS_STORAGE_ENABLED); 2805 MOVED_TO_GLOBAL.add(Settings.Global.USE_GOOGLE_MAIL); 2806 MOVED_TO_GLOBAL.add(Settings.Global.WEB_AUTOFILL_QUERY_URL); 2807 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_COUNTRY_CODE); 2808 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_FRAMEWORK_SCAN_INTERVAL_MS); 2809 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_FREQUENCY_BAND); 2810 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_IDLE_MS); 2811 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_MAX_DHCP_RETRY_COUNT); 2812 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_MOBILE_DATA_TRANSITION_WAKELOCK_TIMEOUT_MS); 2813 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON); 2814 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY); 2815 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_NUM_OPEN_NETWORKS_KEPT); 2816 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_ON); 2817 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_P2P_DEVICE_NAME); 2818 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_SAVED_STATE); 2819 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_SUPPLICANT_SCAN_INTERVAL_MS); 2820 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_SUSPEND_OPTIMIZATIONS_ENABLED); 2821 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_WATCHDOG_ON); 2822 MOVED_TO_GLOBAL.add(Settings.Global.WIFI_WATCHDOG_POOR_NETWORK_TEST_ENABLED); 2823 MOVED_TO_GLOBAL.add(Settings.Global.WIMAX_NETWORKS_AVAILABLE_NOTIFICATION_ON); 2824 MOVED_TO_GLOBAL.add(Settings.Global.PACKAGE_VERIFIER_ENABLE); 2825 MOVED_TO_GLOBAL.add(Settings.Global.PACKAGE_VERIFIER_TIMEOUT); 2826 MOVED_TO_GLOBAL.add(Settings.Global.PACKAGE_VERIFIER_DEFAULT_RESPONSE); 2827 MOVED_TO_GLOBAL.add(Settings.Global.DATA_STALL_ALARM_NON_AGGRESSIVE_DELAY_IN_MS); 2828 MOVED_TO_GLOBAL.add(Settings.Global.DATA_STALL_ALARM_AGGRESSIVE_DELAY_IN_MS); 2829 MOVED_TO_GLOBAL.add(Settings.Global.GPRS_REGISTER_CHECK_PERIOD_MS); 2830 MOVED_TO_GLOBAL.add(Settings.Global.WTF_IS_FATAL); 2831 MOVED_TO_GLOBAL.add(Settings.Global.BATTERY_DISCHARGE_DURATION_THRESHOLD); 2832 MOVED_TO_GLOBAL.add(Settings.Global.BATTERY_DISCHARGE_THRESHOLD); 2833 MOVED_TO_GLOBAL.add(Settings.Global.SEND_ACTION_APP_ERROR); 2834 MOVED_TO_GLOBAL.add(Settings.Global.DROPBOX_AGE_SECONDS); 2835 MOVED_TO_GLOBAL.add(Settings.Global.DROPBOX_MAX_FILES); 2836 MOVED_TO_GLOBAL.add(Settings.Global.DROPBOX_QUOTA_KB); 2837 MOVED_TO_GLOBAL.add(Settings.Global.DROPBOX_QUOTA_PERCENT); 2838 MOVED_TO_GLOBAL.add(Settings.Global.DROPBOX_RESERVE_PERCENT); 2839 MOVED_TO_GLOBAL.add(Settings.Global.DROPBOX_TAG_PREFIX); 2840 MOVED_TO_GLOBAL.add(Settings.Global.ERROR_LOGCAT_PREFIX); 2841 MOVED_TO_GLOBAL.add(Settings.Global.SYS_FREE_STORAGE_LOG_INTERVAL); 2842 MOVED_TO_GLOBAL.add(Settings.Global.DISK_FREE_CHANGE_REPORTING_THRESHOLD); 2843 MOVED_TO_GLOBAL.add(Settings.Global.SYS_STORAGE_THRESHOLD_PERCENTAGE); 2844 MOVED_TO_GLOBAL.add(Settings.Global.SYS_STORAGE_THRESHOLD_MAX_BYTES); 2845 MOVED_TO_GLOBAL.add(Settings.Global.SYS_STORAGE_FULL_THRESHOLD_BYTES); 2846 MOVED_TO_GLOBAL.add(Settings.Global.SYNC_MAX_RETRY_DELAY_IN_SECONDS); 2847 MOVED_TO_GLOBAL.add(Settings.Global.CONNECTIVITY_CHANGE_DELAY); 2848 MOVED_TO_GLOBAL.add(Settings.Global.CAPTIVE_PORTAL_DETECTION_ENABLED); 2849 MOVED_TO_GLOBAL.add(Settings.Global.CAPTIVE_PORTAL_SERVER); 2850 MOVED_TO_GLOBAL.add(Settings.Global.NSD_ON); 2851 MOVED_TO_GLOBAL.add(Settings.Global.SET_INSTALL_LOCATION); 2852 MOVED_TO_GLOBAL.add(Settings.Global.DEFAULT_INSTALL_LOCATION); 2853 MOVED_TO_GLOBAL.add(Settings.Global.INET_CONDITION_DEBOUNCE_UP_DELAY); 2854 MOVED_TO_GLOBAL.add(Settings.Global.INET_CONDITION_DEBOUNCE_DOWN_DELAY); 2855 MOVED_TO_GLOBAL.add(Settings.Global.READ_EXTERNAL_STORAGE_ENFORCED_DEFAULT); 2856 MOVED_TO_GLOBAL.add(Settings.Global.HTTP_PROXY); 2857 MOVED_TO_GLOBAL.add(Settings.Global.GLOBAL_HTTP_PROXY_HOST); 2858 MOVED_TO_GLOBAL.add(Settings.Global.GLOBAL_HTTP_PROXY_PORT); 2859 MOVED_TO_GLOBAL.add(Settings.Global.GLOBAL_HTTP_PROXY_EXCLUSION_LIST); 2860 MOVED_TO_GLOBAL.add(Settings.Global.SET_GLOBAL_HTTP_PROXY); 2861 MOVED_TO_GLOBAL.add(Settings.Global.DEFAULT_DNS_SERVER); 2862 MOVED_TO_GLOBAL.add(Settings.Global.PREFERRED_NETWORK_MODE); 2863 } 2864 2865 /** @hide */ getMovedKeys(HashSet<String> outKeySet)2866 public static void getMovedKeys(HashSet<String> outKeySet) { 2867 outKeySet.addAll(MOVED_TO_GLOBAL); 2868 } 2869 2870 /** 2871 * Look up a name in the database. 2872 * @param resolver to access the database with 2873 * @param name to look up in the table 2874 * @return the corresponding value, or null if not present 2875 */ getString(ContentResolver resolver, String name)2876 public static String getString(ContentResolver resolver, String name) { 2877 return getStringForUser(resolver, name, UserHandle.myUserId()); 2878 } 2879 2880 /** @hide */ getStringForUser(ContentResolver resolver, String name, int userHandle)2881 public static String getStringForUser(ContentResolver resolver, String name, 2882 int userHandle) { 2883 if (MOVED_TO_GLOBAL.contains(name)) { 2884 Log.w(TAG, "Setting " + name + " has moved from android.provider.Settings.Secure" 2885 + " to android.provider.Settings.Global."); 2886 return Global.getStringForUser(resolver, name, userHandle); 2887 } 2888 2889 if (MOVED_TO_LOCK_SETTINGS.contains(name)) { 2890 synchronized (Secure.class) { 2891 if (sLockSettings == null) { 2892 sLockSettings = ILockSettings.Stub.asInterface( 2893 (IBinder) ServiceManager.getService("lock_settings")); 2894 sIsSystemProcess = Process.myUid() == Process.SYSTEM_UID; 2895 } 2896 } 2897 if (sLockSettings != null && !sIsSystemProcess) { 2898 try { 2899 return sLockSettings.getString(name, "0", userHandle); 2900 } catch (RemoteException re) { 2901 // Fall through 2902 } 2903 } 2904 } 2905 2906 return sNameValueCache.getStringForUser(resolver, name, userHandle); 2907 } 2908 2909 /** 2910 * Store a name/value pair into the database. 2911 * @param resolver to access the database with 2912 * @param name to store 2913 * @param value to associate with the name 2914 * @return true if the value was set, false on database errors 2915 */ putString(ContentResolver resolver, String name, String value)2916 public static boolean putString(ContentResolver resolver, String name, String value) { 2917 return putStringForUser(resolver, name, value, UserHandle.myUserId()); 2918 } 2919 2920 /** @hide */ putStringForUser(ContentResolver resolver, String name, String value, int userHandle)2921 public static boolean putStringForUser(ContentResolver resolver, String name, String value, 2922 int userHandle) { 2923 if (MOVED_TO_GLOBAL.contains(name)) { 2924 Log.w(TAG, "Setting " + name + " has moved from android.provider.Settings.System" 2925 + " to android.provider.Settings.Global"); 2926 return Global.putStringForUser(resolver, name, value, userHandle); 2927 } 2928 return sNameValueCache.putStringForUser(resolver, name, value, userHandle); 2929 } 2930 2931 /** 2932 * Construct the content URI for a particular name/value pair, 2933 * useful for monitoring changes with a ContentObserver. 2934 * @param name to look up in the table 2935 * @return the corresponding content URI, or null if not present 2936 */ getUriFor(String name)2937 public static Uri getUriFor(String name) { 2938 if (MOVED_TO_GLOBAL.contains(name)) { 2939 Log.w(TAG, "Setting " + name + " has moved from android.provider.Settings.Secure" 2940 + " to android.provider.Settings.Global, returning global URI."); 2941 return Global.getUriFor(Global.CONTENT_URI, name); 2942 } 2943 return getUriFor(CONTENT_URI, name); 2944 } 2945 2946 /** 2947 * Convenience function for retrieving a single secure settings value 2948 * as an integer. Note that internally setting values are always 2949 * stored as strings; this function converts the string to an integer 2950 * for you. The default value will be returned if the setting is 2951 * not defined or not an integer. 2952 * 2953 * @param cr The ContentResolver to access. 2954 * @param name The name of the setting to retrieve. 2955 * @param def Value to return if the setting is not defined. 2956 * 2957 * @return The setting's current value, or 'def' if it is not defined 2958 * or not a valid integer. 2959 */ getInt(ContentResolver cr, String name, int def)2960 public static int getInt(ContentResolver cr, String name, int def) { 2961 return getIntForUser(cr, name, def, UserHandle.myUserId()); 2962 } 2963 2964 /** @hide */ getIntForUser(ContentResolver cr, String name, int def, int userHandle)2965 public static int getIntForUser(ContentResolver cr, String name, int def, int userHandle) { 2966 if (LOCATION_MODE.equals(name)) { 2967 // HACK ALERT: temporary hack to work around b/10491283. 2968 // TODO: once b/10491283 fixed, remove this hack 2969 return getLocationModeForUser(cr, userHandle); 2970 } 2971 String v = getStringForUser(cr, name, userHandle); 2972 try { 2973 return v != null ? Integer.parseInt(v) : def; 2974 } catch (NumberFormatException e) { 2975 return def; 2976 } 2977 } 2978 2979 /** 2980 * Convenience function for retrieving a single secure settings value 2981 * as an integer. Note that internally setting values are always 2982 * stored as strings; this function converts the string to an integer 2983 * for you. 2984 * <p> 2985 * This version does not take a default value. If the setting has not 2986 * been set, or the string value is not a number, 2987 * it throws {@link SettingNotFoundException}. 2988 * 2989 * @param cr The ContentResolver to access. 2990 * @param name The name of the setting to retrieve. 2991 * 2992 * @throws SettingNotFoundException Thrown if a setting by the given 2993 * name can't be found or the setting value is not an integer. 2994 * 2995 * @return The setting's current value. 2996 */ getInt(ContentResolver cr, String name)2997 public static int getInt(ContentResolver cr, String name) 2998 throws SettingNotFoundException { 2999 return getIntForUser(cr, name, UserHandle.myUserId()); 3000 } 3001 3002 /** @hide */ getIntForUser(ContentResolver cr, String name, int userHandle)3003 public static int getIntForUser(ContentResolver cr, String name, int userHandle) 3004 throws SettingNotFoundException { 3005 if (LOCATION_MODE.equals(name)) { 3006 // HACK ALERT: temporary hack to work around b/10491283. 3007 // TODO: once b/10491283 fixed, remove this hack 3008 return getLocationModeForUser(cr, userHandle); 3009 } 3010 String v = getStringForUser(cr, name, userHandle); 3011 try { 3012 return Integer.parseInt(v); 3013 } catch (NumberFormatException e) { 3014 throw new SettingNotFoundException(name); 3015 } 3016 } 3017 3018 /** 3019 * Convenience function for updating a single settings value as an 3020 * integer. This will either create a new entry in the table if the 3021 * given name does not exist, or modify the value of the existing row 3022 * with that name. Note that internally setting values are always 3023 * stored as strings, so this function converts the given value to a 3024 * string before storing it. 3025 * 3026 * @param cr The ContentResolver to access. 3027 * @param name The name of the setting to modify. 3028 * @param value The new value for the setting. 3029 * @return true if the value was set, false on database errors 3030 */ putInt(ContentResolver cr, String name, int value)3031 public static boolean putInt(ContentResolver cr, String name, int value) { 3032 return putIntForUser(cr, name, value, UserHandle.myUserId()); 3033 } 3034 3035 /** @hide */ putIntForUser(ContentResolver cr, String name, int value, int userHandle)3036 public static boolean putIntForUser(ContentResolver cr, String name, int value, 3037 int userHandle) { 3038 if (LOCATION_MODE.equals(name)) { 3039 // HACK ALERT: temporary hack to work around b/10491283. 3040 // TODO: once b/10491283 fixed, remove this hack 3041 return setLocationModeForUser(cr, value, userHandle); 3042 } 3043 return putStringForUser(cr, name, Integer.toString(value), userHandle); 3044 } 3045 3046 /** 3047 * Convenience function for retrieving a single secure settings value 3048 * as a {@code long}. Note that internally setting values are always 3049 * stored as strings; this function converts the string to a {@code long} 3050 * for you. The default value will be returned if the setting is 3051 * not defined or not a {@code long}. 3052 * 3053 * @param cr The ContentResolver to access. 3054 * @param name The name of the setting to retrieve. 3055 * @param def Value to return if the setting is not defined. 3056 * 3057 * @return The setting's current value, or 'def' if it is not defined 3058 * or not a valid {@code long}. 3059 */ getLong(ContentResolver cr, String name, long def)3060 public static long getLong(ContentResolver cr, String name, long def) { 3061 return getLongForUser(cr, name, def, UserHandle.myUserId()); 3062 } 3063 3064 /** @hide */ getLongForUser(ContentResolver cr, String name, long def, int userHandle)3065 public static long getLongForUser(ContentResolver cr, String name, long def, 3066 int userHandle) { 3067 String valString = getStringForUser(cr, name, userHandle); 3068 long value; 3069 try { 3070 value = valString != null ? Long.parseLong(valString) : def; 3071 } catch (NumberFormatException e) { 3072 value = def; 3073 } 3074 return value; 3075 } 3076 3077 /** 3078 * Convenience function for retrieving a single secure settings value 3079 * as a {@code long}. Note that internally setting values are always 3080 * stored as strings; this function converts the string to a {@code long} 3081 * for you. 3082 * <p> 3083 * This version does not take a default value. If the setting has not 3084 * been set, or the string value is not a number, 3085 * it throws {@link SettingNotFoundException}. 3086 * 3087 * @param cr The ContentResolver to access. 3088 * @param name The name of the setting to retrieve. 3089 * 3090 * @return The setting's current value. 3091 * @throws SettingNotFoundException Thrown if a setting by the given 3092 * name can't be found or the setting value is not an integer. 3093 */ getLong(ContentResolver cr, String name)3094 public static long getLong(ContentResolver cr, String name) 3095 throws SettingNotFoundException { 3096 return getLongForUser(cr, name, UserHandle.myUserId()); 3097 } 3098 3099 /** @hide */ getLongForUser(ContentResolver cr, String name, int userHandle)3100 public static long getLongForUser(ContentResolver cr, String name, int userHandle) 3101 throws SettingNotFoundException { 3102 String valString = getStringForUser(cr, name, userHandle); 3103 try { 3104 return Long.parseLong(valString); 3105 } catch (NumberFormatException e) { 3106 throw new SettingNotFoundException(name); 3107 } 3108 } 3109 3110 /** 3111 * Convenience function for updating a secure settings value as a long 3112 * integer. This will either create a new entry in the table if the 3113 * given name does not exist, or modify the value of the existing row 3114 * with that name. Note that internally setting values are always 3115 * stored as strings, so this function converts the given value to a 3116 * string before storing it. 3117 * 3118 * @param cr The ContentResolver to access. 3119 * @param name The name of the setting to modify. 3120 * @param value The new value for the setting. 3121 * @return true if the value was set, false on database errors 3122 */ putLong(ContentResolver cr, String name, long value)3123 public static boolean putLong(ContentResolver cr, String name, long value) { 3124 return putLongForUser(cr, name, value, UserHandle.myUserId()); 3125 } 3126 3127 /** @hide */ putLongForUser(ContentResolver cr, String name, long value, int userHandle)3128 public static boolean putLongForUser(ContentResolver cr, String name, long value, 3129 int userHandle) { 3130 return putStringForUser(cr, name, Long.toString(value), userHandle); 3131 } 3132 3133 /** 3134 * Convenience function for retrieving a single secure settings value 3135 * as a floating point number. Note that internally setting values are 3136 * always stored as strings; this function converts the string to an 3137 * float for you. The default value will be returned if the setting 3138 * is not defined or not a valid float. 3139 * 3140 * @param cr The ContentResolver to access. 3141 * @param name The name of the setting to retrieve. 3142 * @param def Value to return if the setting is not defined. 3143 * 3144 * @return The setting's current value, or 'def' if it is not defined 3145 * or not a valid float. 3146 */ getFloat(ContentResolver cr, String name, float def)3147 public static float getFloat(ContentResolver cr, String name, float def) { 3148 return getFloatForUser(cr, name, def, UserHandle.myUserId()); 3149 } 3150 3151 /** @hide */ getFloatForUser(ContentResolver cr, String name, float def, int userHandle)3152 public static float getFloatForUser(ContentResolver cr, String name, float def, 3153 int userHandle) { 3154 String v = getStringForUser(cr, name, userHandle); 3155 try { 3156 return v != null ? Float.parseFloat(v) : def; 3157 } catch (NumberFormatException e) { 3158 return def; 3159 } 3160 } 3161 3162 /** 3163 * Convenience function for retrieving a single secure settings value 3164 * as a float. Note that internally setting values are always 3165 * stored as strings; this function converts the string to a float 3166 * for you. 3167 * <p> 3168 * This version does not take a default value. If the setting has not 3169 * been set, or the string value is not a number, 3170 * it throws {@link SettingNotFoundException}. 3171 * 3172 * @param cr The ContentResolver to access. 3173 * @param name The name of the setting to retrieve. 3174 * 3175 * @throws SettingNotFoundException Thrown if a setting by the given 3176 * name can't be found or the setting value is not a float. 3177 * 3178 * @return The setting's current value. 3179 */ getFloat(ContentResolver cr, String name)3180 public static float getFloat(ContentResolver cr, String name) 3181 throws SettingNotFoundException { 3182 return getFloatForUser(cr, name, UserHandle.myUserId()); 3183 } 3184 3185 /** @hide */ getFloatForUser(ContentResolver cr, String name, int userHandle)3186 public static float getFloatForUser(ContentResolver cr, String name, int userHandle) 3187 throws SettingNotFoundException { 3188 String v = getStringForUser(cr, name, userHandle); 3189 if (v == null) { 3190 throw new SettingNotFoundException(name); 3191 } 3192 try { 3193 return Float.parseFloat(v); 3194 } catch (NumberFormatException e) { 3195 throw new SettingNotFoundException(name); 3196 } 3197 } 3198 3199 /** 3200 * Convenience function for updating a single settings value as a 3201 * floating point number. This will either create a new entry in the 3202 * table if the given name does not exist, or modify the value of the 3203 * existing row with that name. Note that internally setting values 3204 * are always stored as strings, so this function converts the given 3205 * value to a string before storing it. 3206 * 3207 * @param cr The ContentResolver to access. 3208 * @param name The name of the setting to modify. 3209 * @param value The new value for the setting. 3210 * @return true if the value was set, false on database errors 3211 */ putFloat(ContentResolver cr, String name, float value)3212 public static boolean putFloat(ContentResolver cr, String name, float value) { 3213 return putFloatForUser(cr, name, value, UserHandle.myUserId()); 3214 } 3215 3216 /** @hide */ putFloatForUser(ContentResolver cr, String name, float value, int userHandle)3217 public static boolean putFloatForUser(ContentResolver cr, String name, float value, 3218 int userHandle) { 3219 return putStringForUser(cr, name, Float.toString(value), userHandle); 3220 } 3221 3222 /** 3223 * @deprecated Use {@link android.provider.Settings.Global#DEVELOPMENT_SETTINGS_ENABLED} 3224 * instead 3225 */ 3226 @Deprecated 3227 public static final String DEVELOPMENT_SETTINGS_ENABLED = 3228 Global.DEVELOPMENT_SETTINGS_ENABLED; 3229 3230 /** 3231 * When the user has enable the option to have a "bug report" command 3232 * in the power menu. 3233 * @deprecated Use {@link android.provider.Settings.Global#BUGREPORT_IN_POWER_MENU} instead 3234 * @hide 3235 */ 3236 @Deprecated 3237 public static final String BUGREPORT_IN_POWER_MENU = "bugreport_in_power_menu"; 3238 3239 /** 3240 * @deprecated Use {@link android.provider.Settings.Global#ADB_ENABLED} instead 3241 */ 3242 @Deprecated 3243 public static final String ADB_ENABLED = Global.ADB_ENABLED; 3244 3245 /** 3246 * Setting to allow mock locations and location provider status to be injected into the 3247 * LocationManager service for testing purposes during application development. These 3248 * locations and status values override actual location and status information generated 3249 * by network, gps, or other location providers. 3250 */ 3251 public static final String ALLOW_MOCK_LOCATION = "mock_location"; 3252 3253 /** 3254 * A 64-bit number (as a hex string) that is randomly 3255 * generated on the device's first boot and should remain 3256 * constant for the lifetime of the device. (The value may 3257 * change if a factory reset is performed on the device.) 3258 */ 3259 public static final String ANDROID_ID = "android_id"; 3260 3261 /** 3262 * @deprecated Use {@link android.provider.Settings.Global#BLUETOOTH_ON} instead 3263 */ 3264 @Deprecated 3265 public static final String BLUETOOTH_ON = Global.BLUETOOTH_ON; 3266 3267 /** 3268 * @deprecated Use {@link android.provider.Settings.Global#DATA_ROAMING} instead 3269 */ 3270 @Deprecated 3271 public static final String DATA_ROAMING = Global.DATA_ROAMING; 3272 3273 /** 3274 * Setting to record the input method used by default, holding the ID 3275 * of the desired method. 3276 */ 3277 public static final String DEFAULT_INPUT_METHOD = "default_input_method"; 3278 3279 /** 3280 * Setting to record the input method subtype used by default, holding the ID 3281 * of the desired method. 3282 */ 3283 public static final String SELECTED_INPUT_METHOD_SUBTYPE = 3284 "selected_input_method_subtype"; 3285 3286 /** 3287 * Setting to record the history of input method subtype, holding the pair of ID of IME 3288 * and its last used subtype. 3289 * @hide 3290 */ 3291 public static final String INPUT_METHODS_SUBTYPE_HISTORY = 3292 "input_methods_subtype_history"; 3293 3294 /** 3295 * Setting to record the visibility of input method selector 3296 */ 3297 public static final String INPUT_METHOD_SELECTOR_VISIBILITY = 3298 "input_method_selector_visibility"; 3299 3300 /** 3301 * bluetooth HCI snoop log configuration 3302 * @hide 3303 */ 3304 public static final String BLUETOOTH_HCI_LOG = 3305 "bluetooth_hci_log"; 3306 3307 /** 3308 * @deprecated Use {@link android.provider.Settings.Global#DEVICE_PROVISIONED} instead 3309 */ 3310 @Deprecated 3311 public static final String DEVICE_PROVISIONED = Global.DEVICE_PROVISIONED; 3312 3313 /** 3314 * Whether the current user has been set up via setup wizard (0 = false, 1 = true) 3315 * @hide 3316 */ 3317 public static final String USER_SETUP_COMPLETE = "user_setup_complete"; 3318 3319 /** 3320 * List of input methods that are currently enabled. This is a string 3321 * containing the IDs of all enabled input methods, each ID separated 3322 * by ':'. 3323 */ 3324 public static final String ENABLED_INPUT_METHODS = "enabled_input_methods"; 3325 3326 /** 3327 * List of system input methods that are currently disabled. This is a string 3328 * containing the IDs of all disabled input methods, each ID separated 3329 * by ':'. 3330 * @hide 3331 */ 3332 public static final String DISABLED_SYSTEM_INPUT_METHODS = "disabled_system_input_methods"; 3333 3334 /** 3335 * Host name and port for global http proxy. Uses ':' seperator for 3336 * between host and port. 3337 * 3338 * @deprecated Use {@link Global#HTTP_PROXY} 3339 */ 3340 @Deprecated 3341 public static final String HTTP_PROXY = Global.HTTP_PROXY; 3342 3343 /** 3344 * @deprecated Use {@link android.provider.Settings.Global#INSTALL_NON_MARKET_APPS} instead 3345 */ 3346 @Deprecated 3347 public static final String INSTALL_NON_MARKET_APPS = Global.INSTALL_NON_MARKET_APPS; 3348 3349 /** 3350 * Comma-separated list of location providers that activities may access. 3351 * 3352 * @deprecated use {@link #LOCATION_MODE} 3353 */ 3354 @Deprecated 3355 public static final String LOCATION_PROVIDERS_ALLOWED = "location_providers_allowed"; 3356 3357 /** 3358 * The degree of location access enabled by the user. 3359 * <p/> 3360 * When used with {@link #putInt(ContentResolver, String, int)}, must be one of {@link 3361 * #LOCATION_MODE_HIGH_ACCURACY}, {@link #LOCATION_MODE_SENSORS_ONLY}, {@link 3362 * #LOCATION_MODE_BATTERY_SAVING}, or {@link #LOCATION_MODE_OFF}. When used with {@link 3363 * #getInt(ContentResolver, String)}, the caller must gracefully handle additional location 3364 * modes that might be added in the future. 3365 */ 3366 public static final String LOCATION_MODE = "location_mode"; 3367 3368 /** 3369 * Location access disabled. 3370 */ 3371 public static final int LOCATION_MODE_OFF = 0; 3372 /** 3373 * Network Location Provider disabled, but GPS and other sensors enabled. 3374 */ 3375 public static final int LOCATION_MODE_SENSORS_ONLY = 1; 3376 /** 3377 * Reduced power usage, such as limiting the number of GPS updates per hour. Requests 3378 * with {@link android.location.Criteria#POWER_HIGH} may be downgraded to 3379 * {@link android.location.Criteria#POWER_MEDIUM}. 3380 */ 3381 public static final int LOCATION_MODE_BATTERY_SAVING = 2; 3382 /** 3383 * Best-effort location computation allowed. 3384 */ 3385 public static final int LOCATION_MODE_HIGH_ACCURACY = 3; 3386 3387 /** 3388 * A flag containing settings used for biometric weak 3389 * @hide 3390 */ 3391 public static final String LOCK_BIOMETRIC_WEAK_FLAGS = 3392 "lock_biometric_weak_flags"; 3393 3394 /** 3395 * Whether autolock is enabled (0 = false, 1 = true) 3396 */ 3397 public static final String LOCK_PATTERN_ENABLED = "lock_pattern_autolock"; 3398 3399 /** 3400 * Whether lock pattern is visible as user enters (0 = false, 1 = true) 3401 */ 3402 public static final String LOCK_PATTERN_VISIBLE = "lock_pattern_visible_pattern"; 3403 3404 /** 3405 * Whether lock pattern will vibrate as user enters (0 = false, 1 = 3406 * true) 3407 * 3408 * @deprecated Starting in {@link VERSION_CODES#JELLY_BEAN_MR1} the 3409 * lockscreen uses 3410 * {@link Settings.System#HAPTIC_FEEDBACK_ENABLED}. 3411 */ 3412 @Deprecated 3413 public static final String 3414 LOCK_PATTERN_TACTILE_FEEDBACK_ENABLED = "lock_pattern_tactile_feedback_enabled"; 3415 3416 /** 3417 * This preference allows the device to be locked given time after screen goes off, 3418 * subject to current DeviceAdmin policy limits. 3419 * @hide 3420 */ 3421 public static final String LOCK_SCREEN_LOCK_AFTER_TIMEOUT = "lock_screen_lock_after_timeout"; 3422 3423 3424 /** 3425 * This preference contains the string that shows for owner info on LockScreen. 3426 * @hide 3427 * @deprecated 3428 */ 3429 public static final String LOCK_SCREEN_OWNER_INFO = "lock_screen_owner_info"; 3430 3431 /** 3432 * Ids of the user-selected appwidgets on the lockscreen (comma-delimited). 3433 * @hide 3434 */ 3435 public static final String LOCK_SCREEN_APPWIDGET_IDS = 3436 "lock_screen_appwidget_ids"; 3437 3438 /** 3439 * Id of the appwidget shown on the lock screen when appwidgets are disabled. 3440 * @hide 3441 */ 3442 public static final String LOCK_SCREEN_FALLBACK_APPWIDGET_ID = 3443 "lock_screen_fallback_appwidget_id"; 3444 3445 /** 3446 * Index of the lockscreen appwidget to restore, -1 if none. 3447 * @hide 3448 */ 3449 public static final String LOCK_SCREEN_STICKY_APPWIDGET = 3450 "lock_screen_sticky_appwidget"; 3451 3452 /** 3453 * This preference enables showing the owner info on LockScreen. 3454 * @hide 3455 * @deprecated 3456 */ 3457 public static final String LOCK_SCREEN_OWNER_INFO_ENABLED = 3458 "lock_screen_owner_info_enabled"; 3459 3460 /** 3461 * The Logging ID (a unique 64-bit value) as a hex string. 3462 * Used as a pseudonymous identifier for logging. 3463 * @deprecated This identifier is poorly initialized and has 3464 * many collisions. It should not be used. 3465 */ 3466 @Deprecated 3467 public static final String LOGGING_ID = "logging_id"; 3468 3469 /** 3470 * @deprecated Use {@link android.provider.Settings.Global#NETWORK_PREFERENCE} instead 3471 */ 3472 @Deprecated 3473 public static final String NETWORK_PREFERENCE = Global.NETWORK_PREFERENCE; 3474 3475 /** 3476 * No longer supported. 3477 */ 3478 public static final String PARENTAL_CONTROL_ENABLED = "parental_control_enabled"; 3479 3480 /** 3481 * No longer supported. 3482 */ 3483 public static final String PARENTAL_CONTROL_LAST_UPDATE = "parental_control_last_update"; 3484 3485 /** 3486 * No longer supported. 3487 */ 3488 public static final String PARENTAL_CONTROL_REDIRECT_URL = "parental_control_redirect_url"; 3489 3490 /** 3491 * Settings classname to launch when Settings is clicked from All 3492 * Applications. Needed because of user testing between the old 3493 * and new Settings apps. 3494 */ 3495 // TODO: 881807 3496 public static final String SETTINGS_CLASSNAME = "settings_classname"; 3497 3498 /** 3499 * @deprecated Use {@link android.provider.Settings.Global#USB_MASS_STORAGE_ENABLED} instead 3500 */ 3501 @Deprecated 3502 public static final String USB_MASS_STORAGE_ENABLED = Global.USB_MASS_STORAGE_ENABLED; 3503 3504 /** 3505 * @deprecated Use {@link android.provider.Settings.Global#USE_GOOGLE_MAIL} instead 3506 */ 3507 @Deprecated 3508 public static final String USE_GOOGLE_MAIL = Global.USE_GOOGLE_MAIL; 3509 3510 /** 3511 * If accessibility is enabled. 3512 */ 3513 public static final String ACCESSIBILITY_ENABLED = "accessibility_enabled"; 3514 3515 /** 3516 * If touch exploration is enabled. 3517 */ 3518 public static final String TOUCH_EXPLORATION_ENABLED = "touch_exploration_enabled"; 3519 3520 /** 3521 * List of the enabled accessibility providers. 3522 */ 3523 public static final String ENABLED_ACCESSIBILITY_SERVICES = 3524 "enabled_accessibility_services"; 3525 3526 /** 3527 * List of the accessibility services to which the user has granted 3528 * permission to put the device into touch exploration mode. 3529 * 3530 * @hide 3531 */ 3532 public static final String TOUCH_EXPLORATION_GRANTED_ACCESSIBILITY_SERVICES = 3533 "touch_exploration_granted_accessibility_services"; 3534 3535 /** 3536 * Whether to speak passwords while in accessibility mode. 3537 */ 3538 public static final String ACCESSIBILITY_SPEAK_PASSWORD = "speak_password"; 3539 3540 /** 3541 * If injection of accessibility enhancing JavaScript screen-reader 3542 * is enabled. 3543 * <p> 3544 * Note: The JavaScript based screen-reader is served by the 3545 * Google infrastructure and enable users with disabilities to 3546 * efficiently navigate in and explore web content. 3547 * </p> 3548 * <p> 3549 * This property represents a boolean value. 3550 * </p> 3551 * @hide 3552 */ 3553 public static final String ACCESSIBILITY_SCRIPT_INJECTION = 3554 "accessibility_script_injection"; 3555 3556 /** 3557 * The URL for the injected JavaScript based screen-reader used 3558 * for providing accessibility of content in WebView. 3559 * <p> 3560 * Note: The JavaScript based screen-reader is served by the 3561 * Google infrastructure and enable users with disabilities to 3562 * efficiently navigate in and explore web content. 3563 * </p> 3564 * <p> 3565 * This property represents a string value. 3566 * </p> 3567 * @hide 3568 */ 3569 public static final String ACCESSIBILITY_SCREEN_READER_URL = 3570 "accessibility_script_injection_url"; 3571 3572 /** 3573 * Key bindings for navigation in built-in accessibility support for web content. 3574 * <p> 3575 * Note: These key bindings are for the built-in accessibility navigation for 3576 * web content which is used as a fall back solution if JavaScript in a WebView 3577 * is not enabled or the user has not opted-in script injection from Google. 3578 * </p> 3579 * <p> 3580 * The bindings are separated by semi-colon. A binding is a mapping from 3581 * a key to a sequence of actions (for more details look at 3582 * android.webkit.AccessibilityInjector). A key is represented as the hexademical 3583 * string representation of an integer obtained from a meta state (optional) shifted 3584 * sixteen times left and bitwise ored with a key code. An action is represented 3585 * as a hexademical string representation of an integer where the first two digits 3586 * are navigation action index, the second, the third, and the fourth digit pairs 3587 * represent the action arguments. The separate actions in a binding are colon 3588 * separated. The key and the action sequence it maps to are separated by equals. 3589 * </p> 3590 * <p> 3591 * For example, the binding below maps the DPAD right button to traverse the 3592 * current navigation axis once without firing an accessibility event and to 3593 * perform the same traversal again but to fire an event: 3594 * <code> 3595 * 0x16=0x01000100:0x01000101; 3596 * </code> 3597 * </p> 3598 * <p> 3599 * The goal of this binding is to enable dynamic rebinding of keys to 3600 * navigation actions for web content without requiring a framework change. 3601 * </p> 3602 * <p> 3603 * This property represents a string value. 3604 * </p> 3605 * @hide 3606 */ 3607 public static final String ACCESSIBILITY_WEB_CONTENT_KEY_BINDINGS = 3608 "accessibility_web_content_key_bindings"; 3609 3610 /** 3611 * Setting that specifies whether the display magnification is enabled. 3612 * Display magnifications allows the user to zoom in the display content 3613 * and is targeted to low vision users. The current magnification scale 3614 * is controlled by {@link #ACCESSIBILITY_DISPLAY_MAGNIFICATION_SCALE}. 3615 * 3616 * @hide 3617 */ 3618 public static final String ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED = 3619 "accessibility_display_magnification_enabled"; 3620 3621 /** 3622 * Setting that specifies what the display magnification scale is. 3623 * Display magnifications allows the user to zoom in the display 3624 * content and is targeted to low vision users. Whether a display 3625 * magnification is performed is controlled by 3626 * {@link #ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED} 3627 * 3628 * @hide 3629 */ 3630 public static final String ACCESSIBILITY_DISPLAY_MAGNIFICATION_SCALE = 3631 "accessibility_display_magnification_scale"; 3632 3633 /** 3634 * Setting that specifies whether the display magnification should be 3635 * automatically updated. If this fearture is enabled the system will 3636 * exit magnification mode or pan the viewport when a context change 3637 * occurs. For example, on staring a new activity or rotating the screen, 3638 * the system may zoom out so the user can see the new context he is in. 3639 * Another example is on showing a window that is not visible in the 3640 * magnified viewport the system may pan the viewport to make the window 3641 * the has popped up so the user knows that the context has changed. 3642 * Whether a screen magnification is performed is controlled by 3643 * {@link #ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED} 3644 * 3645 * @hide 3646 */ 3647 public static final String ACCESSIBILITY_DISPLAY_MAGNIFICATION_AUTO_UPDATE = 3648 "accessibility_display_magnification_auto_update"; 3649 3650 /** 3651 * Setting that specifies whether timed text (captions) should be 3652 * displayed in video content. Text display properties are controlled by 3653 * the following settings: 3654 * <ul> 3655 * <li>{@link #ACCESSIBILITY_CAPTIONING_LOCALE} 3656 * <li>{@link #ACCESSIBILITY_CAPTIONING_BACKGROUND_COLOR} 3657 * <li>{@link #ACCESSIBILITY_CAPTIONING_FOREGROUND_COLOR} 3658 * <li>{@link #ACCESSIBILITY_CAPTIONING_EDGE_COLOR} 3659 * <li>{@link #ACCESSIBILITY_CAPTIONING_EDGE_TYPE} 3660 * <li>{@link #ACCESSIBILITY_CAPTIONING_TYPEFACE} 3661 * <li>{@link #ACCESSIBILITY_CAPTIONING_FONT_SCALE} 3662 * </ul> 3663 * 3664 * @hide 3665 */ 3666 public static final String ACCESSIBILITY_CAPTIONING_ENABLED = 3667 "accessibility_captioning_enabled"; 3668 3669 /** 3670 * Setting that specifies the language for captions as a locale string, 3671 * e.g. en_US. 3672 * 3673 * @see java.util.Locale#toString 3674 * @hide 3675 */ 3676 public static final String ACCESSIBILITY_CAPTIONING_LOCALE = 3677 "accessibility_captioning_locale"; 3678 3679 /** 3680 * Integer property that specifies the preset style for captions, one 3681 * of: 3682 * <ul> 3683 * <li>{@link android.view.accessibility.CaptioningManager.CaptionStyle#PRESET_CUSTOM} 3684 * <li>a valid index of {@link android.view.accessibility.CaptioningManager.CaptionStyle#PRESETS} 3685 * </ul> 3686 * 3687 * @see java.util.Locale#toString 3688 * @hide 3689 */ 3690 public static final String ACCESSIBILITY_CAPTIONING_PRESET = 3691 "accessibility_captioning_preset"; 3692 3693 /** 3694 * Integer property that specifes the background color for captions as a 3695 * packed 32-bit color. 3696 * 3697 * @see android.graphics.Color#argb 3698 * @hide 3699 */ 3700 public static final String ACCESSIBILITY_CAPTIONING_BACKGROUND_COLOR = 3701 "accessibility_captioning_background_color"; 3702 3703 /** 3704 * Integer property that specifes the foreground color for captions as a 3705 * packed 32-bit color. 3706 * 3707 * @see android.graphics.Color#argb 3708 * @hide 3709 */ 3710 public static final String ACCESSIBILITY_CAPTIONING_FOREGROUND_COLOR = 3711 "accessibility_captioning_foreground_color"; 3712 3713 /** 3714 * Integer property that specifes the edge type for captions, one of: 3715 * <ul> 3716 * <li>{@link android.view.accessibility.CaptioningManager.CaptionStyle#EDGE_TYPE_NONE} 3717 * <li>{@link android.view.accessibility.CaptioningManager.CaptionStyle#EDGE_TYPE_OUTLINE} 3718 * <li>{@link android.view.accessibility.CaptioningManager.CaptionStyle#EDGE_TYPE_DROP_SHADOW} 3719 * </ul> 3720 * 3721 * @see #ACCESSIBILITY_CAPTIONING_EDGE_COLOR 3722 * @hide 3723 */ 3724 public static final String ACCESSIBILITY_CAPTIONING_EDGE_TYPE = 3725 "accessibility_captioning_edge_type"; 3726 3727 /** 3728 * Integer property that specifes the edge color for captions as a 3729 * packed 32-bit color. 3730 * 3731 * @see #ACCESSIBILITY_CAPTIONING_EDGE_TYPE 3732 * @see android.graphics.Color#argb 3733 * @hide 3734 */ 3735 public static final String ACCESSIBILITY_CAPTIONING_EDGE_COLOR = 3736 "accessibility_captioning_edge_color"; 3737 3738 /** 3739 * String property that specifies the typeface for captions, one of: 3740 * <ul> 3741 * <li>DEFAULT 3742 * <li>MONOSPACE 3743 * <li>SANS_SERIF 3744 * <li>SERIF 3745 * </ul> 3746 * 3747 * @see android.graphics.Typeface 3748 * @hide 3749 */ 3750 public static final String ACCESSIBILITY_CAPTIONING_TYPEFACE = 3751 "accessibility_captioning_typeface"; 3752 3753 /** 3754 * Floating point property that specifies font scaling for captions. 3755 * 3756 * @hide 3757 */ 3758 public static final String ACCESSIBILITY_CAPTIONING_FONT_SCALE = 3759 "accessibility_captioning_font_scale"; 3760 3761 /** 3762 * The timout for considering a press to be a long press in milliseconds. 3763 * @hide 3764 */ 3765 public static final String LONG_PRESS_TIMEOUT = "long_press_timeout"; 3766 3767 /** 3768 * List of the enabled print services. 3769 * @hide 3770 */ 3771 public static final String ENABLED_PRINT_SERVICES = 3772 "enabled_print_services"; 3773 3774 /** 3775 * List of the system print services we enabled on first boot. On 3776 * first boot we enable all system, i.e. bundled print services, 3777 * once, so they work out-of-the-box. 3778 * @hide 3779 */ 3780 public static final String ENABLED_ON_FIRST_BOOT_SYSTEM_PRINT_SERVICES = 3781 "enabled_on_first_boot_system_print_services"; 3782 3783 /** 3784 * Setting to always use the default text-to-speech settings regardless 3785 * of the application settings. 3786 * 1 = override application settings, 3787 * 0 = use application settings (if specified). 3788 * 3789 * @deprecated The value of this setting is no longer respected by 3790 * the framework text to speech APIs as of the Ice Cream Sandwich release. 3791 */ 3792 @Deprecated 3793 public static final String TTS_USE_DEFAULTS = "tts_use_defaults"; 3794 3795 /** 3796 * Default text-to-speech engine speech rate. 100 = 1x 3797 */ 3798 public static final String TTS_DEFAULT_RATE = "tts_default_rate"; 3799 3800 /** 3801 * Default text-to-speech engine pitch. 100 = 1x 3802 */ 3803 public static final String TTS_DEFAULT_PITCH = "tts_default_pitch"; 3804 3805 /** 3806 * Default text-to-speech engine. 3807 */ 3808 public static final String TTS_DEFAULT_SYNTH = "tts_default_synth"; 3809 3810 /** 3811 * Default text-to-speech language. 3812 * 3813 * @deprecated this setting is no longer in use, as of the Ice Cream 3814 * Sandwich release. Apps should never need to read this setting directly, 3815 * instead can query the TextToSpeech framework classes for the default 3816 * locale. {@link TextToSpeech#getLanguage()}. 3817 */ 3818 @Deprecated 3819 public static final String TTS_DEFAULT_LANG = "tts_default_lang"; 3820 3821 /** 3822 * Default text-to-speech country. 3823 * 3824 * @deprecated this setting is no longer in use, as of the Ice Cream 3825 * Sandwich release. Apps should never need to read this setting directly, 3826 * instead can query the TextToSpeech framework classes for the default 3827 * locale. {@link TextToSpeech#getLanguage()}. 3828 */ 3829 @Deprecated 3830 public static final String TTS_DEFAULT_COUNTRY = "tts_default_country"; 3831 3832 /** 3833 * Default text-to-speech locale variant. 3834 * 3835 * @deprecated this setting is no longer in use, as of the Ice Cream 3836 * Sandwich release. Apps should never need to read this setting directly, 3837 * instead can query the TextToSpeech framework classes for the 3838 * locale that is in use {@link TextToSpeech#getLanguage()}. 3839 */ 3840 @Deprecated 3841 public static final String TTS_DEFAULT_VARIANT = "tts_default_variant"; 3842 3843 /** 3844 * Stores the default tts locales on a per engine basis. Stored as 3845 * a comma seperated list of values, each value being of the form 3846 * {@code engine_name:locale} for example, 3847 * {@code com.foo.ttsengine:eng-USA,com.bar.ttsengine:esp-ESP}. This 3848 * supersedes {@link #TTS_DEFAULT_LANG}, {@link #TTS_DEFAULT_COUNTRY} and 3849 * {@link #TTS_DEFAULT_VARIANT}. Apps should never need to read this 3850 * setting directly, and can query the TextToSpeech framework classes 3851 * for the locale that is in use. 3852 * 3853 * @hide 3854 */ 3855 public static final String TTS_DEFAULT_LOCALE = "tts_default_locale"; 3856 3857 /** 3858 * Space delimited list of plugin packages that are enabled. 3859 */ 3860 public static final String TTS_ENABLED_PLUGINS = "tts_enabled_plugins"; 3861 3862 /** 3863 * @deprecated Use {@link android.provider.Settings.Global#WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON} 3864 * instead. 3865 */ 3866 @Deprecated 3867 public static final String WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON = 3868 Global.WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON; 3869 3870 /** 3871 * @deprecated Use {@link android.provider.Settings.Global#WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY} 3872 * instead. 3873 */ 3874 @Deprecated 3875 public static final String WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY = 3876 Global.WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY; 3877 3878 /** 3879 * @deprecated Use {@link android.provider.Settings.Global#WIFI_NUM_OPEN_NETWORKS_KEPT} 3880 * instead. 3881 */ 3882 @Deprecated 3883 public static final String WIFI_NUM_OPEN_NETWORKS_KEPT = 3884 Global.WIFI_NUM_OPEN_NETWORKS_KEPT; 3885 3886 /** 3887 * @deprecated Use {@link android.provider.Settings.Global#WIFI_ON} 3888 * instead. 3889 */ 3890 @Deprecated 3891 public static final String WIFI_ON = Global.WIFI_ON; 3892 3893 /** 3894 * The acceptable packet loss percentage (range 0 - 100) before trying 3895 * another AP on the same network. 3896 * @deprecated This setting is not used. 3897 */ 3898 @Deprecated 3899 public static final String WIFI_WATCHDOG_ACCEPTABLE_PACKET_LOSS_PERCENTAGE = 3900 "wifi_watchdog_acceptable_packet_loss_percentage"; 3901 3902 /** 3903 * The number of access points required for a network in order for the 3904 * watchdog to monitor it. 3905 * @deprecated This setting is not used. 3906 */ 3907 @Deprecated 3908 public static final String WIFI_WATCHDOG_AP_COUNT = "wifi_watchdog_ap_count"; 3909 3910 /** 3911 * The delay between background checks. 3912 * @deprecated This setting is not used. 3913 */ 3914 @Deprecated 3915 public static final String WIFI_WATCHDOG_BACKGROUND_CHECK_DELAY_MS = 3916 "wifi_watchdog_background_check_delay_ms"; 3917 3918 /** 3919 * Whether the Wi-Fi watchdog is enabled for background checking even 3920 * after it thinks the user has connected to a good access point. 3921 * @deprecated This setting is not used. 3922 */ 3923 @Deprecated 3924 public static final String WIFI_WATCHDOG_BACKGROUND_CHECK_ENABLED = 3925 "wifi_watchdog_background_check_enabled"; 3926 3927 /** 3928 * The timeout for a background ping 3929 * @deprecated This setting is not used. 3930 */ 3931 @Deprecated 3932 public static final String WIFI_WATCHDOG_BACKGROUND_CHECK_TIMEOUT_MS = 3933 "wifi_watchdog_background_check_timeout_ms"; 3934 3935 /** 3936 * The number of initial pings to perform that *may* be ignored if they 3937 * fail. Again, if these fail, they will *not* be used in packet loss 3938 * calculation. For example, one network always seemed to time out for 3939 * the first couple pings, so this is set to 3 by default. 3940 * @deprecated This setting is not used. 3941 */ 3942 @Deprecated 3943 public static final String WIFI_WATCHDOG_INITIAL_IGNORED_PING_COUNT = 3944 "wifi_watchdog_initial_ignored_ping_count"; 3945 3946 /** 3947 * The maximum number of access points (per network) to attempt to test. 3948 * If this number is reached, the watchdog will no longer monitor the 3949 * initial connection state for the network. This is a safeguard for 3950 * networks containing multiple APs whose DNS does not respond to pings. 3951 * @deprecated This setting is not used. 3952 */ 3953 @Deprecated 3954 public static final String WIFI_WATCHDOG_MAX_AP_CHECKS = "wifi_watchdog_max_ap_checks"; 3955 3956 /** 3957 * @deprecated Use {@link android.provider.Settings.Global#WIFI_WATCHDOG_ON} instead 3958 */ 3959 @Deprecated 3960 public static final String WIFI_WATCHDOG_ON = "wifi_watchdog_on"; 3961 3962 /** 3963 * A comma-separated list of SSIDs for which the Wi-Fi watchdog should be enabled. 3964 * @deprecated This setting is not used. 3965 */ 3966 @Deprecated 3967 public static final String WIFI_WATCHDOG_WATCH_LIST = "wifi_watchdog_watch_list"; 3968 3969 /** 3970 * The number of pings to test if an access point is a good connection. 3971 * @deprecated This setting is not used. 3972 */ 3973 @Deprecated 3974 public static final String WIFI_WATCHDOG_PING_COUNT = "wifi_watchdog_ping_count"; 3975 3976 /** 3977 * The delay between pings. 3978 * @deprecated This setting is not used. 3979 */ 3980 @Deprecated 3981 public static final String WIFI_WATCHDOG_PING_DELAY_MS = "wifi_watchdog_ping_delay_ms"; 3982 3983 /** 3984 * The timeout per ping. 3985 * @deprecated This setting is not used. 3986 */ 3987 @Deprecated 3988 public static final String WIFI_WATCHDOG_PING_TIMEOUT_MS = "wifi_watchdog_ping_timeout_ms"; 3989 3990 /** 3991 * @deprecated Use 3992 * {@link android.provider.Settings.Global#WIFI_MAX_DHCP_RETRY_COUNT} instead 3993 */ 3994 @Deprecated 3995 public static final String WIFI_MAX_DHCP_RETRY_COUNT = Global.WIFI_MAX_DHCP_RETRY_COUNT; 3996 3997 /** 3998 * @deprecated Use 3999 * {@link android.provider.Settings.Global#WIFI_MOBILE_DATA_TRANSITION_WAKELOCK_TIMEOUT_MS} instead 4000 */ 4001 @Deprecated 4002 public static final String WIFI_MOBILE_DATA_TRANSITION_WAKELOCK_TIMEOUT_MS = 4003 Global.WIFI_MOBILE_DATA_TRANSITION_WAKELOCK_TIMEOUT_MS; 4004 4005 /** 4006 * Whether background data usage is allowed. 4007 * 4008 * @deprecated As of {@link VERSION_CODES#ICE_CREAM_SANDWICH}, 4009 * availability of background data depends on several 4010 * combined factors. When background data is unavailable, 4011 * {@link ConnectivityManager#getActiveNetworkInfo()} will 4012 * now appear disconnected. 4013 */ 4014 @Deprecated 4015 public static final String BACKGROUND_DATA = "background_data"; 4016 4017 /** 4018 * Origins for which browsers should allow geolocation by default. 4019 * The value is a space-separated list of origins. 4020 */ 4021 public static final String ALLOWED_GEOLOCATION_ORIGINS 4022 = "allowed_geolocation_origins"; 4023 4024 /** 4025 * The preferred TTY mode 0 = TTy Off, CDMA default 4026 * 1 = TTY Full 4027 * 2 = TTY HCO 4028 * 3 = TTY VCO 4029 * @hide 4030 */ 4031 public static final String PREFERRED_TTY_MODE = 4032 "preferred_tty_mode"; 4033 4034 /** 4035 * Whether the enhanced voice privacy mode is enabled. 4036 * 0 = normal voice privacy 4037 * 1 = enhanced voice privacy 4038 * @hide 4039 */ 4040 public static final String ENHANCED_VOICE_PRIVACY_ENABLED = "enhanced_voice_privacy_enabled"; 4041 4042 /** 4043 * Whether the TTY mode mode is enabled. 4044 * 0 = disabled 4045 * 1 = enabled 4046 * @hide 4047 */ 4048 public static final String TTY_MODE_ENABLED = "tty_mode_enabled"; 4049 4050 /** 4051 * Controls whether settings backup is enabled. 4052 * Type: int ( 0 = disabled, 1 = enabled ) 4053 * @hide 4054 */ 4055 public static final String BACKUP_ENABLED = "backup_enabled"; 4056 4057 /** 4058 * Controls whether application data is automatically restored from backup 4059 * at install time. 4060 * Type: int ( 0 = disabled, 1 = enabled ) 4061 * @hide 4062 */ 4063 public static final String BACKUP_AUTO_RESTORE = "backup_auto_restore"; 4064 4065 /** 4066 * Indicates whether settings backup has been fully provisioned. 4067 * Type: int ( 0 = unprovisioned, 1 = fully provisioned ) 4068 * @hide 4069 */ 4070 public static final String BACKUP_PROVISIONED = "backup_provisioned"; 4071 4072 /** 4073 * Component of the transport to use for backup/restore. 4074 * @hide 4075 */ 4076 public static final String BACKUP_TRANSPORT = "backup_transport"; 4077 4078 /** 4079 * Version for which the setup wizard was last shown. Bumped for 4080 * each release when there is new setup information to show. 4081 * @hide 4082 */ 4083 public static final String LAST_SETUP_SHOWN = "last_setup_shown"; 4084 4085 /** 4086 * The interval in milliseconds after which Wi-Fi is considered idle. 4087 * When idle, it is possible for the device to be switched from Wi-Fi to 4088 * the mobile data network. 4089 * @hide 4090 * @deprecated Use {@link android.provider.Settings.Global#WIFI_IDLE_MS} 4091 * instead. 4092 */ 4093 @Deprecated 4094 public static final String WIFI_IDLE_MS = Global.WIFI_IDLE_MS; 4095 4096 /** 4097 * The global search provider chosen by the user (if multiple global 4098 * search providers are installed). This will be the provider returned 4099 * by {@link SearchManager#getGlobalSearchActivity()} if it's still 4100 * installed. This setting is stored as a flattened component name as 4101 * per {@link ComponentName#flattenToString()}. 4102 * 4103 * @hide 4104 */ 4105 public static final String SEARCH_GLOBAL_SEARCH_ACTIVITY = 4106 "search_global_search_activity"; 4107 4108 /** 4109 * The number of promoted sources in GlobalSearch. 4110 * @hide 4111 */ 4112 public static final String SEARCH_NUM_PROMOTED_SOURCES = "search_num_promoted_sources"; 4113 /** 4114 * The maximum number of suggestions returned by GlobalSearch. 4115 * @hide 4116 */ 4117 public static final String SEARCH_MAX_RESULTS_TO_DISPLAY = "search_max_results_to_display"; 4118 /** 4119 * The number of suggestions GlobalSearch will ask each non-web search source for. 4120 * @hide 4121 */ 4122 public static final String SEARCH_MAX_RESULTS_PER_SOURCE = "search_max_results_per_source"; 4123 /** 4124 * The number of suggestions the GlobalSearch will ask the web search source for. 4125 * @hide 4126 */ 4127 public static final String SEARCH_WEB_RESULTS_OVERRIDE_LIMIT = 4128 "search_web_results_override_limit"; 4129 /** 4130 * The number of milliseconds that GlobalSearch will wait for suggestions from 4131 * promoted sources before continuing with all other sources. 4132 * @hide 4133 */ 4134 public static final String SEARCH_PROMOTED_SOURCE_DEADLINE_MILLIS = 4135 "search_promoted_source_deadline_millis"; 4136 /** 4137 * The number of milliseconds before GlobalSearch aborts search suggesiton queries. 4138 * @hide 4139 */ 4140 public static final String SEARCH_SOURCE_TIMEOUT_MILLIS = "search_source_timeout_millis"; 4141 /** 4142 * The maximum number of milliseconds that GlobalSearch shows the previous results 4143 * after receiving a new query. 4144 * @hide 4145 */ 4146 public static final String SEARCH_PREFILL_MILLIS = "search_prefill_millis"; 4147 /** 4148 * The maximum age of log data used for shortcuts in GlobalSearch. 4149 * @hide 4150 */ 4151 public static final String SEARCH_MAX_STAT_AGE_MILLIS = "search_max_stat_age_millis"; 4152 /** 4153 * The maximum age of log data used for source ranking in GlobalSearch. 4154 * @hide 4155 */ 4156 public static final String SEARCH_MAX_SOURCE_EVENT_AGE_MILLIS = 4157 "search_max_source_event_age_millis"; 4158 /** 4159 * The minimum number of impressions needed to rank a source in GlobalSearch. 4160 * @hide 4161 */ 4162 public static final String SEARCH_MIN_IMPRESSIONS_FOR_SOURCE_RANKING = 4163 "search_min_impressions_for_source_ranking"; 4164 /** 4165 * The minimum number of clicks needed to rank a source in GlobalSearch. 4166 * @hide 4167 */ 4168 public static final String SEARCH_MIN_CLICKS_FOR_SOURCE_RANKING = 4169 "search_min_clicks_for_source_ranking"; 4170 /** 4171 * The maximum number of shortcuts shown by GlobalSearch. 4172 * @hide 4173 */ 4174 public static final String SEARCH_MAX_SHORTCUTS_RETURNED = "search_max_shortcuts_returned"; 4175 /** 4176 * The size of the core thread pool for suggestion queries in GlobalSearch. 4177 * @hide 4178 */ 4179 public static final String SEARCH_QUERY_THREAD_CORE_POOL_SIZE = 4180 "search_query_thread_core_pool_size"; 4181 /** 4182 * The maximum size of the thread pool for suggestion queries in GlobalSearch. 4183 * @hide 4184 */ 4185 public static final String SEARCH_QUERY_THREAD_MAX_POOL_SIZE = 4186 "search_query_thread_max_pool_size"; 4187 /** 4188 * The size of the core thread pool for shortcut refreshing in GlobalSearch. 4189 * @hide 4190 */ 4191 public static final String SEARCH_SHORTCUT_REFRESH_CORE_POOL_SIZE = 4192 "search_shortcut_refresh_core_pool_size"; 4193 /** 4194 * The maximum size of the thread pool for shortcut refreshing in GlobalSearch. 4195 * @hide 4196 */ 4197 public static final String SEARCH_SHORTCUT_REFRESH_MAX_POOL_SIZE = 4198 "search_shortcut_refresh_max_pool_size"; 4199 /** 4200 * The maximun time that excess threads in the GlobalSeach thread pools will 4201 * wait before terminating. 4202 * @hide 4203 */ 4204 public static final String SEARCH_THREAD_KEEPALIVE_SECONDS = 4205 "search_thread_keepalive_seconds"; 4206 /** 4207 * The maximum number of concurrent suggestion queries to each source. 4208 * @hide 4209 */ 4210 public static final String SEARCH_PER_SOURCE_CONCURRENT_QUERY_LIMIT = 4211 "search_per_source_concurrent_query_limit"; 4212 4213 /** 4214 * Whether or not alert sounds are played on MountService events. (0 = false, 1 = true) 4215 * @hide 4216 */ 4217 public static final String MOUNT_PLAY_NOTIFICATION_SND = "mount_play_not_snd"; 4218 4219 /** 4220 * Whether or not UMS auto-starts on UMS host detection. (0 = false, 1 = true) 4221 * @hide 4222 */ 4223 public static final String MOUNT_UMS_AUTOSTART = "mount_ums_autostart"; 4224 4225 /** 4226 * Whether or not a notification is displayed on UMS host detection. (0 = false, 1 = true) 4227 * @hide 4228 */ 4229 public static final String MOUNT_UMS_PROMPT = "mount_ums_prompt"; 4230 4231 /** 4232 * Whether or not a notification is displayed while UMS is enabled. (0 = false, 1 = true) 4233 * @hide 4234 */ 4235 public static final String MOUNT_UMS_NOTIFY_ENABLED = "mount_ums_notify_enabled"; 4236 4237 /** 4238 * If nonzero, ANRs in invisible background processes bring up a dialog. 4239 * Otherwise, the process will be silently killed. 4240 * @hide 4241 */ 4242 public static final String ANR_SHOW_BACKGROUND = "anr_show_background"; 4243 4244 /** 4245 * The {@link ComponentName} string of the service to be used as the voice recognition 4246 * service. 4247 * 4248 * @hide 4249 */ 4250 public static final String VOICE_RECOGNITION_SERVICE = "voice_recognition_service"; 4251 4252 /** 4253 * Stores whether an user has consented to have apps verified through PAM. 4254 * The value is boolean (1 or 0). 4255 * 4256 * @hide 4257 */ 4258 public static final String PACKAGE_VERIFIER_USER_CONSENT = 4259 "package_verifier_user_consent"; 4260 4261 /** 4262 * The {@link ComponentName} string of the selected spell checker service which is 4263 * one of the services managed by the text service manager. 4264 * 4265 * @hide 4266 */ 4267 public static final String SELECTED_SPELL_CHECKER = "selected_spell_checker"; 4268 4269 /** 4270 * The {@link ComponentName} string of the selected subtype of the selected spell checker 4271 * service which is one of the services managed by the text service manager. 4272 * 4273 * @hide 4274 */ 4275 public static final String SELECTED_SPELL_CHECKER_SUBTYPE = 4276 "selected_spell_checker_subtype"; 4277 4278 /** 4279 * The {@link ComponentName} string whether spell checker is enabled or not. 4280 * 4281 * @hide 4282 */ 4283 public static final String SPELL_CHECKER_ENABLED = "spell_checker_enabled"; 4284 4285 /** 4286 * What happens when the user presses the Power button while in-call 4287 * and the screen is on.<br/> 4288 * <b>Values:</b><br/> 4289 * 1 - The Power button turns off the screen and locks the device. (Default behavior)<br/> 4290 * 2 - The Power button hangs up the current call.<br/> 4291 * 4292 * @hide 4293 */ 4294 public static final String INCALL_POWER_BUTTON_BEHAVIOR = "incall_power_button_behavior"; 4295 4296 /** 4297 * INCALL_POWER_BUTTON_BEHAVIOR value for "turn off screen". 4298 * @hide 4299 */ 4300 public static final int INCALL_POWER_BUTTON_BEHAVIOR_SCREEN_OFF = 0x1; 4301 4302 /** 4303 * INCALL_POWER_BUTTON_BEHAVIOR value for "hang up". 4304 * @hide 4305 */ 4306 public static final int INCALL_POWER_BUTTON_BEHAVIOR_HANGUP = 0x2; 4307 4308 /** 4309 * INCALL_POWER_BUTTON_BEHAVIOR default value. 4310 * @hide 4311 */ 4312 public static final int INCALL_POWER_BUTTON_BEHAVIOR_DEFAULT = 4313 INCALL_POWER_BUTTON_BEHAVIOR_SCREEN_OFF; 4314 4315 /** 4316 * The current night mode that has been selected by the user. Owned 4317 * and controlled by UiModeManagerService. Constants are as per 4318 * UiModeManager. 4319 * @hide 4320 */ 4321 public static final String UI_NIGHT_MODE = "ui_night_mode"; 4322 4323 /** 4324 * Whether screensavers are enabled. 4325 * @hide 4326 */ 4327 public static final String SCREENSAVER_ENABLED = "screensaver_enabled"; 4328 4329 /** 4330 * The user's chosen screensaver components. 4331 * 4332 * These will be launched by the PhoneWindowManager after a timeout when not on 4333 * battery, or upon dock insertion (if SCREENSAVER_ACTIVATE_ON_DOCK is set to 1). 4334 * @hide 4335 */ 4336 public static final String SCREENSAVER_COMPONENTS = "screensaver_components"; 4337 4338 /** 4339 * If screensavers are enabled, whether the screensaver should be automatically launched 4340 * when the device is inserted into a (desk) dock. 4341 * @hide 4342 */ 4343 public static final String SCREENSAVER_ACTIVATE_ON_DOCK = "screensaver_activate_on_dock"; 4344 4345 /** 4346 * If screensavers are enabled, whether the screensaver should be automatically launched 4347 * when the screen times out when not on battery. 4348 * @hide 4349 */ 4350 public static final String SCREENSAVER_ACTIVATE_ON_SLEEP = "screensaver_activate_on_sleep"; 4351 4352 /** 4353 * If screensavers are enabled, the default screensaver component. 4354 * @hide 4355 */ 4356 public static final String SCREENSAVER_DEFAULT_COMPONENT = "screensaver_default_component"; 4357 4358 /** 4359 * The default NFC payment component 4360 * @hide 4361 */ 4362 public static final String NFC_PAYMENT_DEFAULT_COMPONENT = "nfc_payment_default_component"; 4363 4364 /** 4365 * Specifies the package name currently configured to be the primary sms application 4366 * @hide 4367 */ 4368 public static final String SMS_DEFAULT_APPLICATION = "sms_default_application"; 4369 4370 /** 4371 * Name of a package that the current user has explicitly allowed to see all of that 4372 * user's notifications. 4373 * 4374 * @hide 4375 */ 4376 public static final String ENABLED_NOTIFICATION_LISTENERS = "enabled_notification_listeners"; 4377 4378 /** @hide */ 4379 public static final String BAR_SERVICE_COMPONENT = "bar_service_component"; 4380 4381 /** @hide */ 4382 public static final String IMMERSIVE_MODE_CONFIRMATIONS = "immersive_mode_confirmations"; 4383 4384 /** 4385 * This is the query URI for finding a print service to install. 4386 * 4387 * @hide 4388 */ 4389 public static final String PRINT_SERVICE_SEARCH_URI = "print_service_search_uri"; 4390 4391 /** 4392 * This is the query URI for finding a NFC payment service to install. 4393 * 4394 * @hide 4395 */ 4396 public static final String PAYMENT_SERVICE_SEARCH_URI = "payment_service_search_uri"; 4397 4398 /** 4399 * This are the settings to be backed up. 4400 * 4401 * NOTE: Settings are backed up and restored in the order they appear 4402 * in this array. If you have one setting depending on another, 4403 * make sure that they are ordered appropriately. 4404 * 4405 * @hide 4406 */ 4407 public static final String[] SETTINGS_TO_BACKUP = { 4408 BUGREPORT_IN_POWER_MENU, // moved to global 4409 ALLOW_MOCK_LOCATION, 4410 PARENTAL_CONTROL_ENABLED, 4411 PARENTAL_CONTROL_REDIRECT_URL, 4412 USB_MASS_STORAGE_ENABLED, // moved to global 4413 ACCESSIBILITY_DISPLAY_MAGNIFICATION_ENABLED, 4414 ACCESSIBILITY_DISPLAY_MAGNIFICATION_SCALE, 4415 ACCESSIBILITY_DISPLAY_MAGNIFICATION_AUTO_UPDATE, 4416 ACCESSIBILITY_SCRIPT_INJECTION, 4417 BACKUP_AUTO_RESTORE, 4418 ENABLED_ACCESSIBILITY_SERVICES, 4419 TOUCH_EXPLORATION_GRANTED_ACCESSIBILITY_SERVICES, 4420 TOUCH_EXPLORATION_ENABLED, 4421 ACCESSIBILITY_ENABLED, 4422 ACCESSIBILITY_SPEAK_PASSWORD, 4423 ACCESSIBILITY_CAPTIONING_ENABLED, 4424 ACCESSIBILITY_CAPTIONING_LOCALE, 4425 ACCESSIBILITY_CAPTIONING_BACKGROUND_COLOR, 4426 ACCESSIBILITY_CAPTIONING_FOREGROUND_COLOR, 4427 ACCESSIBILITY_CAPTIONING_EDGE_TYPE, 4428 ACCESSIBILITY_CAPTIONING_EDGE_COLOR, 4429 ACCESSIBILITY_CAPTIONING_TYPEFACE, 4430 ACCESSIBILITY_CAPTIONING_FONT_SCALE, 4431 TTS_USE_DEFAULTS, 4432 TTS_DEFAULT_RATE, 4433 TTS_DEFAULT_PITCH, 4434 TTS_DEFAULT_SYNTH, 4435 TTS_DEFAULT_LANG, 4436 TTS_DEFAULT_COUNTRY, 4437 TTS_ENABLED_PLUGINS, 4438 TTS_DEFAULT_LOCALE, 4439 WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON, // moved to global 4440 WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY, // moved to global 4441 WIFI_NUM_OPEN_NETWORKS_KEPT, // moved to global 4442 MOUNT_PLAY_NOTIFICATION_SND, 4443 MOUNT_UMS_AUTOSTART, 4444 MOUNT_UMS_PROMPT, 4445 MOUNT_UMS_NOTIFY_ENABLED, 4446 UI_NIGHT_MODE 4447 }; 4448 4449 /** 4450 * Helper method for determining if a location provider is enabled. 4451 * 4452 * @param cr the content resolver to use 4453 * @param provider the location provider to query 4454 * @return true if the provider is enabled 4455 * 4456 * @deprecated use {@link #LOCATION_MODE} or 4457 * {@link LocationManager#isProviderEnabled(String)} 4458 */ 4459 @Deprecated isLocationProviderEnabled(ContentResolver cr, String provider)4460 public static final boolean isLocationProviderEnabled(ContentResolver cr, String provider) { 4461 return isLocationProviderEnabledForUser(cr, provider, UserHandle.myUserId()); 4462 } 4463 4464 /** 4465 * Helper method for determining if a location provider is enabled. 4466 * @param cr the content resolver to use 4467 * @param provider the location provider to query 4468 * @param userId the userId to query 4469 * @return true if the provider is enabled 4470 * @deprecated use {@link #LOCATION_MODE} or 4471 * {@link LocationManager#isProviderEnabled(String)} 4472 * @hide 4473 */ 4474 @Deprecated isLocationProviderEnabledForUser(ContentResolver cr, String provider, int userId)4475 public static final boolean isLocationProviderEnabledForUser(ContentResolver cr, String provider, int userId) { 4476 String allowedProviders = Settings.Secure.getStringForUser(cr, 4477 LOCATION_PROVIDERS_ALLOWED, userId); 4478 return TextUtils.delimitedStringContains(allowedProviders, ',', provider); 4479 } 4480 4481 /** 4482 * Thread-safe method for enabling or disabling a single location provider. 4483 * @param cr the content resolver to use 4484 * @param provider the location provider to enable or disable 4485 * @param enabled true if the provider should be enabled 4486 * @deprecated use {@link #putInt(ContentResolver, String, int)} and {@link #LOCATION_MODE} 4487 */ 4488 @Deprecated setLocationProviderEnabled(ContentResolver cr, String provider, boolean enabled)4489 public static final void setLocationProviderEnabled(ContentResolver cr, 4490 String provider, boolean enabled) { 4491 setLocationProviderEnabledForUser(cr, provider, enabled, UserHandle.myUserId()); 4492 } 4493 4494 /** 4495 * Thread-safe method for enabling or disabling a single location provider. 4496 * 4497 * @param cr the content resolver to use 4498 * @param provider the location provider to enable or disable 4499 * @param enabled true if the provider should be enabled 4500 * @param userId the userId for which to enable/disable providers 4501 * @return true if the value was set, false on database errors 4502 * @deprecated use {@link #putIntForUser(ContentResolver, String, int, int)} and 4503 * {@link #LOCATION_MODE} 4504 * @hide 4505 */ 4506 @Deprecated setLocationProviderEnabledForUser(ContentResolver cr, String provider, boolean enabled, int userId)4507 public static final boolean setLocationProviderEnabledForUser(ContentResolver cr, 4508 String provider, boolean enabled, int userId) { 4509 synchronized (mLocationSettingsLock) { 4510 // to ensure thread safety, we write the provider name with a '+' or '-' 4511 // and let the SettingsProvider handle it rather than reading and modifying 4512 // the list of enabled providers. 4513 if (enabled) { 4514 provider = "+" + provider; 4515 } else { 4516 provider = "-" + provider; 4517 } 4518 return putStringForUser(cr, Settings.Secure.LOCATION_PROVIDERS_ALLOWED, provider, 4519 userId); 4520 } 4521 } 4522 4523 /** 4524 * Thread-safe method for setting the location mode to one of 4525 * {@link #LOCATION_MODE_HIGH_ACCURACY}, {@link #LOCATION_MODE_SENSORS_ONLY}, 4526 * {@link #LOCATION_MODE_BATTERY_SAVING}, or {@link #LOCATION_MODE_OFF}. 4527 * 4528 * @param cr the content resolver to use 4529 * @param mode such as {@link #LOCATION_MODE_HIGH_ACCURACY} 4530 * @param userId the userId for which to change mode 4531 * @return true if the value was set, false on database errors 4532 * 4533 * @throws IllegalArgumentException if mode is not one of the supported values 4534 */ setLocationModeForUser(ContentResolver cr, int mode, int userId)4535 private static final boolean setLocationModeForUser(ContentResolver cr, int mode, 4536 int userId) { 4537 synchronized (mLocationSettingsLock) { 4538 boolean gps = false; 4539 boolean network = false; 4540 switch (mode) { 4541 case LOCATION_MODE_OFF: 4542 break; 4543 case LOCATION_MODE_SENSORS_ONLY: 4544 gps = true; 4545 break; 4546 case LOCATION_MODE_BATTERY_SAVING: 4547 network = true; 4548 break; 4549 case LOCATION_MODE_HIGH_ACCURACY: 4550 gps = true; 4551 network = true; 4552 break; 4553 default: 4554 throw new IllegalArgumentException("Invalid location mode: " + mode); 4555 } 4556 boolean gpsSuccess = Settings.Secure.setLocationProviderEnabledForUser( 4557 cr, LocationManager.GPS_PROVIDER, gps, userId); 4558 boolean nlpSuccess = Settings.Secure.setLocationProviderEnabledForUser( 4559 cr, LocationManager.NETWORK_PROVIDER, network, userId); 4560 return gpsSuccess && nlpSuccess; 4561 } 4562 } 4563 4564 /** 4565 * Thread-safe method for reading the location mode, returns one of 4566 * {@link #LOCATION_MODE_HIGH_ACCURACY}, {@link #LOCATION_MODE_SENSORS_ONLY}, 4567 * {@link #LOCATION_MODE_BATTERY_SAVING}, or {@link #LOCATION_MODE_OFF}. 4568 * 4569 * @param cr the content resolver to use 4570 * @param userId the userId for which to read the mode 4571 * @return the location mode 4572 */ getLocationModeForUser(ContentResolver cr, int userId)4573 private static final int getLocationModeForUser(ContentResolver cr, int userId) { 4574 synchronized (mLocationSettingsLock) { 4575 boolean gpsEnabled = Settings.Secure.isLocationProviderEnabledForUser( 4576 cr, LocationManager.GPS_PROVIDER, userId); 4577 boolean networkEnabled = Settings.Secure.isLocationProviderEnabledForUser( 4578 cr, LocationManager.NETWORK_PROVIDER, userId); 4579 if (gpsEnabled && networkEnabled) { 4580 return LOCATION_MODE_HIGH_ACCURACY; 4581 } else if (gpsEnabled) { 4582 return LOCATION_MODE_SENSORS_ONLY; 4583 } else if (networkEnabled) { 4584 return LOCATION_MODE_BATTERY_SAVING; 4585 } else { 4586 return LOCATION_MODE_OFF; 4587 } 4588 } 4589 } 4590 } 4591 4592 /** 4593 * Global system settings, containing preferences that always apply identically 4594 * to all defined users. Applications can read these but are not allowed to write; 4595 * like the "Secure" settings, these are for preferences that the user must 4596 * explicitly modify through the system UI or specialized APIs for those values. 4597 */ 4598 public static final class Global extends NameValueTable { 4599 public static final String SYS_PROP_SETTING_VERSION = "sys.settings_global_version"; 4600 4601 /** 4602 * The content:// style URL for global secure settings items. Not public. 4603 */ 4604 public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/global"); 4605 4606 /** 4607 * Setting whether the global gesture for enabling accessibility is enabled. 4608 * If this gesture is enabled the user will be able to perfrom it to enable 4609 * the accessibility state without visiting the settings app. 4610 * @hide 4611 */ 4612 public static final String ENABLE_ACCESSIBILITY_GLOBAL_GESTURE_ENABLED = 4613 "enable_accessibility_global_gesture_enabled"; 4614 4615 /** 4616 * Whether Airplane Mode is on. 4617 */ 4618 public static final String AIRPLANE_MODE_ON = "airplane_mode_on"; 4619 4620 /** 4621 * Constant for use in AIRPLANE_MODE_RADIOS to specify Bluetooth radio. 4622 */ 4623 public static final String RADIO_BLUETOOTH = "bluetooth"; 4624 4625 /** 4626 * Constant for use in AIRPLANE_MODE_RADIOS to specify Wi-Fi radio. 4627 */ 4628 public static final String RADIO_WIFI = "wifi"; 4629 4630 /** 4631 * {@hide} 4632 */ 4633 public static final String RADIO_WIMAX = "wimax"; 4634 /** 4635 * Constant for use in AIRPLANE_MODE_RADIOS to specify Cellular radio. 4636 */ 4637 public static final String RADIO_CELL = "cell"; 4638 4639 /** 4640 * Constant for use in AIRPLANE_MODE_RADIOS to specify NFC radio. 4641 */ 4642 public static final String RADIO_NFC = "nfc"; 4643 4644 /** 4645 * A comma separated list of radios that need to be disabled when airplane mode 4646 * is on. This overrides WIFI_ON and BLUETOOTH_ON, if Wi-Fi and bluetooth are 4647 * included in the comma separated list. 4648 */ 4649 public static final String AIRPLANE_MODE_RADIOS = "airplane_mode_radios"; 4650 4651 /** 4652 * A comma separated list of radios that should to be disabled when airplane mode 4653 * is on, but can be manually reenabled by the user. For example, if RADIO_WIFI is 4654 * added to both AIRPLANE_MODE_RADIOS and AIRPLANE_MODE_TOGGLEABLE_RADIOS, then Wifi 4655 * will be turned off when entering airplane mode, but the user will be able to reenable 4656 * Wifi in the Settings app. 4657 * 4658 * {@hide} 4659 */ 4660 public static final String AIRPLANE_MODE_TOGGLEABLE_RADIOS = "airplane_mode_toggleable_radios"; 4661 4662 /** 4663 * The policy for deciding when Wi-Fi should go to sleep (which will in 4664 * turn switch to using the mobile data as an Internet connection). 4665 * <p> 4666 * Set to one of {@link #WIFI_SLEEP_POLICY_DEFAULT}, 4667 * {@link #WIFI_SLEEP_POLICY_NEVER_WHILE_PLUGGED}, or 4668 * {@link #WIFI_SLEEP_POLICY_NEVER}. 4669 */ 4670 public static final String WIFI_SLEEP_POLICY = "wifi_sleep_policy"; 4671 4672 /** 4673 * Value for {@link #WIFI_SLEEP_POLICY} to use the default Wi-Fi sleep 4674 * policy, which is to sleep shortly after the turning off 4675 * according to the {@link #STAY_ON_WHILE_PLUGGED_IN} setting. 4676 */ 4677 public static final int WIFI_SLEEP_POLICY_DEFAULT = 0; 4678 4679 /** 4680 * Value for {@link #WIFI_SLEEP_POLICY} to use the default policy when 4681 * the device is on battery, and never go to sleep when the device is 4682 * plugged in. 4683 */ 4684 public static final int WIFI_SLEEP_POLICY_NEVER_WHILE_PLUGGED = 1; 4685 4686 /** 4687 * Value for {@link #WIFI_SLEEP_POLICY} to never go to sleep. 4688 */ 4689 public static final int WIFI_SLEEP_POLICY_NEVER = 2; 4690 4691 /** 4692 * Value to specify if the user prefers the date, time and time zone 4693 * to be automatically fetched from the network (NITZ). 1=yes, 0=no 4694 */ 4695 public static final String AUTO_TIME = "auto_time"; 4696 4697 /** 4698 * Value to specify if the user prefers the time zone 4699 * to be automatically fetched from the network (NITZ). 1=yes, 0=no 4700 */ 4701 public static final String AUTO_TIME_ZONE = "auto_time_zone"; 4702 4703 /** 4704 * URI for the car dock "in" event sound. 4705 * @hide 4706 */ 4707 public static final String CAR_DOCK_SOUND = "car_dock_sound"; 4708 4709 /** 4710 * URI for the car dock "out" event sound. 4711 * @hide 4712 */ 4713 public static final String CAR_UNDOCK_SOUND = "car_undock_sound"; 4714 4715 /** 4716 * URI for the desk dock "in" event sound. 4717 * @hide 4718 */ 4719 public static final String DESK_DOCK_SOUND = "desk_dock_sound"; 4720 4721 /** 4722 * URI for the desk dock "out" event sound. 4723 * @hide 4724 */ 4725 public static final String DESK_UNDOCK_SOUND = "desk_undock_sound"; 4726 4727 /** 4728 * Whether to play a sound for dock events. 4729 * @hide 4730 */ 4731 public static final String DOCK_SOUNDS_ENABLED = "dock_sounds_enabled"; 4732 4733 /** 4734 * URI for the "device locked" (keyguard shown) sound. 4735 * @hide 4736 */ 4737 public static final String LOCK_SOUND = "lock_sound"; 4738 4739 /** 4740 * URI for the "device unlocked" sound. 4741 * @hide 4742 */ 4743 public static final String UNLOCK_SOUND = "unlock_sound"; 4744 4745 /** 4746 * URI for the low battery sound file. 4747 * @hide 4748 */ 4749 public static final String LOW_BATTERY_SOUND = "low_battery_sound"; 4750 4751 /** 4752 * Whether to play a sound for low-battery alerts. 4753 * @hide 4754 */ 4755 public static final String POWER_SOUNDS_ENABLED = "power_sounds_enabled"; 4756 4757 /** 4758 * URI for the "wireless charging started" sound. 4759 * @hide 4760 */ 4761 public static final String WIRELESS_CHARGING_STARTED_SOUND = 4762 "wireless_charging_started_sound"; 4763 4764 /** 4765 * Whether we keep the device on while the device is plugged in. 4766 * Supported values are: 4767 * <ul> 4768 * <li>{@code 0} to never stay on while plugged in</li> 4769 * <li>{@link BatteryManager#BATTERY_PLUGGED_AC} to stay on for AC charger</li> 4770 * <li>{@link BatteryManager#BATTERY_PLUGGED_USB} to stay on for USB charger</li> 4771 * <li>{@link BatteryManager#BATTERY_PLUGGED_WIRELESS} to stay on for wireless charger</li> 4772 * </ul> 4773 * These values can be OR-ed together. 4774 */ 4775 public static final String STAY_ON_WHILE_PLUGGED_IN = "stay_on_while_plugged_in"; 4776 4777 /** 4778 * When the user has enable the option to have a "bug report" command 4779 * in the power menu. 4780 * @hide 4781 */ 4782 public static final String BUGREPORT_IN_POWER_MENU = "bugreport_in_power_menu"; 4783 4784 /** 4785 * Whether ADB is enabled. 4786 */ 4787 public static final String ADB_ENABLED = "adb_enabled"; 4788 4789 /** 4790 * Whether assisted GPS should be enabled or not. 4791 * @hide 4792 */ 4793 public static final String ASSISTED_GPS_ENABLED = "assisted_gps_enabled"; 4794 4795 /** 4796 * Whether bluetooth is enabled/disabled 4797 * 0=disabled. 1=enabled. 4798 */ 4799 public static final String BLUETOOTH_ON = "bluetooth_on"; 4800 4801 /** 4802 * CDMA Cell Broadcast SMS 4803 * 0 = CDMA Cell Broadcast SMS disabled 4804 * 1 = CDMA Cell Broadcast SMS enabled 4805 * @hide 4806 */ 4807 public static final String CDMA_CELL_BROADCAST_SMS = 4808 "cdma_cell_broadcast_sms"; 4809 4810 /** 4811 * The CDMA roaming mode 0 = Home Networks, CDMA default 4812 * 1 = Roaming on Affiliated networks 4813 * 2 = Roaming on any networks 4814 * @hide 4815 */ 4816 public static final String CDMA_ROAMING_MODE = "roaming_settings"; 4817 4818 /** 4819 * The CDMA subscription mode 0 = RUIM/SIM (default) 4820 * 1 = NV 4821 * @hide 4822 */ 4823 public static final String CDMA_SUBSCRIPTION_MODE = "subscription_mode"; 4824 4825 /** Inactivity timeout to track mobile data activity. 4826 * 4827 * If set to a positive integer, it indicates the inactivity timeout value in seconds to 4828 * infer the data activity of mobile network. After a period of no activity on mobile 4829 * networks with length specified by the timeout, an {@code ACTION_DATA_ACTIVITY_CHANGE} 4830 * intent is fired to indicate a transition of network status from "active" to "idle". Any 4831 * subsequent activity on mobile networks triggers the firing of {@code 4832 * ACTION_DATA_ACTIVITY_CHANGE} intent indicating transition from "idle" to "active". 4833 * 4834 * Network activity refers to transmitting or receiving data on the network interfaces. 4835 * 4836 * Tracking is disabled if set to zero or negative value. 4837 * 4838 * @hide 4839 */ 4840 public static final String DATA_ACTIVITY_TIMEOUT_MOBILE = "data_activity_timeout_mobile"; 4841 4842 /** Timeout to tracking Wifi data activity. Same as {@code DATA_ACTIVITY_TIMEOUT_MOBILE} 4843 * but for Wifi network. 4844 * @hide 4845 */ 4846 public static final String DATA_ACTIVITY_TIMEOUT_WIFI = "data_activity_timeout_wifi"; 4847 4848 /** 4849 * Whether or not data roaming is enabled. (0 = false, 1 = true) 4850 */ 4851 public static final String DATA_ROAMING = "data_roaming"; 4852 4853 /** 4854 * The value passed to a Mobile DataConnection via bringUp which defines the 4855 * number of retries to preform when setting up the initial connection. The default 4856 * value defined in DataConnectionTrackerBase#DEFAULT_MDC_INITIAL_RETRY is currently 1. 4857 * @hide 4858 */ 4859 public static final String MDC_INITIAL_MAX_RETRY = "mdc_initial_max_retry"; 4860 4861 /** 4862 * Whether user has enabled development settings. 4863 */ 4864 public static final String DEVELOPMENT_SETTINGS_ENABLED = "development_settings_enabled"; 4865 4866 /** 4867 * Whether the device has been provisioned (0 = false, 1 = true) 4868 */ 4869 public static final String DEVICE_PROVISIONED = "device_provisioned"; 4870 4871 /** 4872 * The saved value for WindowManagerService.setForcedDisplayDensity(). 4873 * One integer in dpi. If unset, then use the real display density. 4874 * @hide 4875 */ 4876 public static final String DISPLAY_DENSITY_FORCED = "display_density_forced"; 4877 4878 /** 4879 * The saved value for WindowManagerService.setForcedDisplaySize(). 4880 * Two integers separated by a comma. If unset, then use the real display size. 4881 * @hide 4882 */ 4883 public static final String DISPLAY_SIZE_FORCED = "display_size_forced"; 4884 4885 /** 4886 * The maximum size, in bytes, of a download that the download manager will transfer over 4887 * a non-wifi connection. 4888 * @hide 4889 */ 4890 public static final String DOWNLOAD_MAX_BYTES_OVER_MOBILE = 4891 "download_manager_max_bytes_over_mobile"; 4892 4893 /** 4894 * The recommended maximum size, in bytes, of a download that the download manager should 4895 * transfer over a non-wifi connection. Over this size, the use will be warned, but will 4896 * have the option to start the download over the mobile connection anyway. 4897 * @hide 4898 */ 4899 public static final String DOWNLOAD_RECOMMENDED_MAX_BYTES_OVER_MOBILE = 4900 "download_manager_recommended_max_bytes_over_mobile"; 4901 4902 /** 4903 * Whether the package installer should allow installation of apps downloaded from 4904 * sources other than Google Play. 4905 * 4906 * 1 = allow installing from other sources 4907 * 0 = only allow installing from Google Play 4908 */ 4909 public static final String INSTALL_NON_MARKET_APPS = "install_non_market_apps"; 4910 4911 /** 4912 * Whether mobile data connections are allowed by the user. See 4913 * ConnectivityManager for more info. 4914 * @hide 4915 */ 4916 public static final String MOBILE_DATA = "mobile_data"; 4917 4918 /** {@hide} */ 4919 public static final String NETSTATS_ENABLED = "netstats_enabled"; 4920 /** {@hide} */ 4921 public static final String NETSTATS_POLL_INTERVAL = "netstats_poll_interval"; 4922 /** {@hide} */ 4923 public static final String NETSTATS_TIME_CACHE_MAX_AGE = "netstats_time_cache_max_age"; 4924 /** {@hide} */ 4925 public static final String NETSTATS_GLOBAL_ALERT_BYTES = "netstats_global_alert_bytes"; 4926 /** {@hide} */ 4927 public static final String NETSTATS_SAMPLE_ENABLED = "netstats_sample_enabled"; 4928 /** {@hide} */ 4929 public static final String NETSTATS_REPORT_XT_OVER_DEV = "netstats_report_xt_over_dev"; 4930 4931 /** {@hide} */ 4932 public static final String NETSTATS_DEV_BUCKET_DURATION = "netstats_dev_bucket_duration"; 4933 /** {@hide} */ 4934 public static final String NETSTATS_DEV_PERSIST_BYTES = "netstats_dev_persist_bytes"; 4935 /** {@hide} */ 4936 public static final String NETSTATS_DEV_ROTATE_AGE = "netstats_dev_rotate_age"; 4937 /** {@hide} */ 4938 public static final String NETSTATS_DEV_DELETE_AGE = "netstats_dev_delete_age"; 4939 4940 /** {@hide} */ 4941 public static final String NETSTATS_UID_BUCKET_DURATION = "netstats_uid_bucket_duration"; 4942 /** {@hide} */ 4943 public static final String NETSTATS_UID_PERSIST_BYTES = "netstats_uid_persist_bytes"; 4944 /** {@hide} */ 4945 public static final String NETSTATS_UID_ROTATE_AGE = "netstats_uid_rotate_age"; 4946 /** {@hide} */ 4947 public static final String NETSTATS_UID_DELETE_AGE = "netstats_uid_delete_age"; 4948 4949 /** {@hide} */ 4950 public static final String NETSTATS_UID_TAG_BUCKET_DURATION = "netstats_uid_tag_bucket_duration"; 4951 /** {@hide} */ 4952 public static final String NETSTATS_UID_TAG_PERSIST_BYTES = "netstats_uid_tag_persist_bytes"; 4953 /** {@hide} */ 4954 public static final String NETSTATS_UID_TAG_ROTATE_AGE = "netstats_uid_tag_rotate_age"; 4955 /** {@hide} */ 4956 public static final String NETSTATS_UID_TAG_DELETE_AGE = "netstats_uid_tag_delete_age"; 4957 4958 /** 4959 * User preference for which network(s) should be used. Only the 4960 * connectivity service should touch this. 4961 */ 4962 public static final String NETWORK_PREFERENCE = "network_preference"; 4963 4964 /** 4965 * If the NITZ_UPDATE_DIFF time is exceeded then an automatic adjustment 4966 * to SystemClock will be allowed even if NITZ_UPDATE_SPACING has not been 4967 * exceeded. 4968 * @hide 4969 */ 4970 public static final String NITZ_UPDATE_DIFF = "nitz_update_diff"; 4971 4972 /** 4973 * The length of time in milli-seconds that automatic small adjustments to 4974 * SystemClock are ignored if NITZ_UPDATE_DIFF is not exceeded. 4975 * @hide 4976 */ 4977 public static final String NITZ_UPDATE_SPACING = "nitz_update_spacing"; 4978 4979 /** Preferred NTP server. {@hide} */ 4980 public static final String NTP_SERVER = "ntp_server"; 4981 /** Timeout in milliseconds to wait for NTP server. {@hide} */ 4982 public static final String NTP_TIMEOUT = "ntp_timeout"; 4983 4984 /** 4985 * Whether the package manager should send package verification broadcasts for verifiers to 4986 * review apps prior to installation. 4987 * 1 = request apps to be verified prior to installation, if a verifier exists. 4988 * 0 = do not verify apps before installation 4989 * @hide 4990 */ 4991 public static final String PACKAGE_VERIFIER_ENABLE = "package_verifier_enable"; 4992 4993 /** Timeout for package verification. 4994 * @hide */ 4995 public static final String PACKAGE_VERIFIER_TIMEOUT = "verifier_timeout"; 4996 4997 /** Default response code for package verification. 4998 * @hide */ 4999 public static final String PACKAGE_VERIFIER_DEFAULT_RESPONSE = "verifier_default_response"; 5000 5001 /** 5002 * Show package verification setting in the Settings app. 5003 * 1 = show (default) 5004 * 0 = hide 5005 * @hide 5006 */ 5007 public static final String PACKAGE_VERIFIER_SETTING_VISIBLE = "verifier_setting_visible"; 5008 5009 /** 5010 * Run package verificaiton on apps installed through ADB/ADT/USB 5011 * 1 = perform package verification on ADB installs (default) 5012 * 0 = bypass package verification on ADB installs 5013 * @hide 5014 */ 5015 public static final String PACKAGE_VERIFIER_INCLUDE_ADB = "verifier_verify_adb_installs"; 5016 5017 /** 5018 * The interval in milliseconds at which to check packet counts on the 5019 * mobile data interface when screen is on, to detect possible data 5020 * connection problems. 5021 * @hide 5022 */ 5023 public static final String PDP_WATCHDOG_POLL_INTERVAL_MS = 5024 "pdp_watchdog_poll_interval_ms"; 5025 5026 /** 5027 * The interval in milliseconds at which to check packet counts on the 5028 * mobile data interface when screen is off, to detect possible data 5029 * connection problems. 5030 * @hide 5031 */ 5032 public static final String PDP_WATCHDOG_LONG_POLL_INTERVAL_MS = 5033 "pdp_watchdog_long_poll_interval_ms"; 5034 5035 /** 5036 * The interval in milliseconds at which to check packet counts on the 5037 * mobile data interface after {@link #PDP_WATCHDOG_TRIGGER_PACKET_COUNT} 5038 * outgoing packets has been reached without incoming packets. 5039 * @hide 5040 */ 5041 public static final String PDP_WATCHDOG_ERROR_POLL_INTERVAL_MS = 5042 "pdp_watchdog_error_poll_interval_ms"; 5043 5044 /** 5045 * The number of outgoing packets sent without seeing an incoming packet 5046 * that triggers a countdown (of {@link #PDP_WATCHDOG_ERROR_POLL_COUNT} 5047 * device is logged to the event log 5048 * @hide 5049 */ 5050 public static final String PDP_WATCHDOG_TRIGGER_PACKET_COUNT = 5051 "pdp_watchdog_trigger_packet_count"; 5052 5053 /** 5054 * The number of polls to perform (at {@link #PDP_WATCHDOG_ERROR_POLL_INTERVAL_MS}) 5055 * after hitting {@link #PDP_WATCHDOG_TRIGGER_PACKET_COUNT} before 5056 * attempting data connection recovery. 5057 * @hide 5058 */ 5059 public static final String PDP_WATCHDOG_ERROR_POLL_COUNT = 5060 "pdp_watchdog_error_poll_count"; 5061 5062 /** 5063 * The number of failed PDP reset attempts before moving to something more 5064 * drastic: re-registering to the network. 5065 * @hide 5066 */ 5067 public static final String PDP_WATCHDOG_MAX_PDP_RESET_FAIL_COUNT = 5068 "pdp_watchdog_max_pdp_reset_fail_count"; 5069 5070 /** 5071 * A positive value indicates how often the SamplingProfiler 5072 * should take snapshots. Zero value means SamplingProfiler 5073 * is disabled. 5074 * 5075 * @hide 5076 */ 5077 public static final String SAMPLING_PROFILER_MS = "sampling_profiler_ms"; 5078 5079 /** 5080 * URL to open browser on to allow user to manage a prepay account 5081 * @hide 5082 */ 5083 public static final String SETUP_PREPAID_DATA_SERVICE_URL = 5084 "setup_prepaid_data_service_url"; 5085 5086 /** 5087 * URL to attempt a GET on to see if this is a prepay device 5088 * @hide 5089 */ 5090 public static final String SETUP_PREPAID_DETECTION_TARGET_URL = 5091 "setup_prepaid_detection_target_url"; 5092 5093 /** 5094 * Host to check for a redirect to after an attempt to GET 5095 * SETUP_PREPAID_DETECTION_TARGET_URL. (If we redirected there, 5096 * this is a prepaid device with zero balance.) 5097 * @hide 5098 */ 5099 public static final String SETUP_PREPAID_DETECTION_REDIR_HOST = 5100 "setup_prepaid_detection_redir_host"; 5101 5102 /** 5103 * The interval in milliseconds at which to check the number of SMS sent out without asking 5104 * for use permit, to limit the un-authorized SMS usage. 5105 * 5106 * @hide 5107 */ 5108 public static final String SMS_OUTGOING_CHECK_INTERVAL_MS = 5109 "sms_outgoing_check_interval_ms"; 5110 5111 /** 5112 * The number of outgoing SMS sent without asking for user permit (of {@link 5113 * #SMS_OUTGOING_CHECK_INTERVAL_MS} 5114 * 5115 * @hide 5116 */ 5117 public static final String SMS_OUTGOING_CHECK_MAX_COUNT = 5118 "sms_outgoing_check_max_count"; 5119 5120 /** 5121 * Used to disable SMS short code confirmation - defaults to true. 5122 * True indcates we will do the check, etc. Set to false to disable. 5123 * @see com.android.internal.telephony.SmsUsageMonitor 5124 * @hide 5125 */ 5126 public static final String SMS_SHORT_CODE_CONFIRMATION = "sms_short_code_confirmation"; 5127 5128 /** 5129 * Used to select which country we use to determine premium sms codes. 5130 * One of com.android.internal.telephony.SMSDispatcher.PREMIUM_RULE_USE_SIM, 5131 * com.android.internal.telephony.SMSDispatcher.PREMIUM_RULE_USE_NETWORK, 5132 * or com.android.internal.telephony.SMSDispatcher.PREMIUM_RULE_USE_BOTH. 5133 * @hide 5134 */ 5135 public static final String SMS_SHORT_CODE_RULE = "sms_short_code_rule"; 5136 5137 /** 5138 * Used to select TCP's default initial receiver window size in segments - defaults to a build config value 5139 * @hide 5140 */ 5141 public static final String TCP_DEFAULT_INIT_RWND = "tcp_default_init_rwnd"; 5142 5143 /** 5144 * Used to disable Tethering on a device - defaults to true 5145 * @hide 5146 */ 5147 public static final String TETHER_SUPPORTED = "tether_supported"; 5148 5149 /** 5150 * Used to require DUN APN on the device or not - defaults to a build config value 5151 * which defaults to false 5152 * @hide 5153 */ 5154 public static final String TETHER_DUN_REQUIRED = "tether_dun_required"; 5155 5156 /** 5157 * Used to hold a gservices-provisioned apn value for DUN. If set, or the 5158 * corresponding build config values are set it will override the APN DB 5159 * values. 5160 * Consists of a comma seperated list of strings: 5161 * "name,apn,proxy,port,username,password,server,mmsc,mmsproxy,mmsport,mcc,mnc,auth,type" 5162 * note that empty fields can be ommitted: "name,apn,,,,,,,,,310,260,,DUN" 5163 * @hide 5164 */ 5165 public static final String TETHER_DUN_APN = "tether_dun_apn"; 5166 5167 /** 5168 * USB Mass Storage Enabled 5169 */ 5170 public static final String USB_MASS_STORAGE_ENABLED = "usb_mass_storage_enabled"; 5171 5172 /** 5173 * If this setting is set (to anything), then all references 5174 * to Gmail on the device must change to Google Mail. 5175 */ 5176 public static final String USE_GOOGLE_MAIL = "use_google_mail"; 5177 5178 /** Autofill server address (Used in WebView/browser). 5179 * {@hide} */ 5180 public static final String WEB_AUTOFILL_QUERY_URL = 5181 "web_autofill_query_url"; 5182 5183 /** 5184 * Whether Wifi display is enabled/disabled 5185 * 0=disabled. 1=enabled. 5186 * @hide 5187 */ 5188 public static final String WIFI_DISPLAY_ON = "wifi_display_on"; 5189 5190 /** 5191 * Whether Wifi display certification mode is enabled/disabled 5192 * 0=disabled. 1=enabled. 5193 * @hide 5194 */ 5195 public static final String WIFI_DISPLAY_CERTIFICATION_ON = 5196 "wifi_display_certification_on"; 5197 5198 /** 5199 * WPS Configuration method used by Wifi display, this setting only 5200 * takes effect when WIFI_DISPLAY_CERTIFICATION_ON is 1 (enabled). 5201 * 5202 * Possible values are: 5203 * 5204 * WpsInfo.INVALID: use default WPS method chosen by framework 5205 * WpsInfo.PBC : use Push button 5206 * WpsInfo.KEYPAD : use Keypad 5207 * WpsInfo.DISPLAY: use Display 5208 * @hide 5209 */ 5210 public static final String WIFI_DISPLAY_WPS_CONFIG = 5211 "wifi_display_wps_config"; 5212 5213 /** 5214 * Whether to notify the user of open networks. 5215 * <p> 5216 * If not connected and the scan results have an open network, we will 5217 * put this notification up. If we attempt to connect to a network or 5218 * the open network(s) disappear, we remove the notification. When we 5219 * show the notification, we will not show it again for 5220 * {@link android.provider.Settings.Secure#WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY} time. 5221 */ 5222 public static final String WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON = 5223 "wifi_networks_available_notification_on"; 5224 /** 5225 * {@hide} 5226 */ 5227 public static final String WIMAX_NETWORKS_AVAILABLE_NOTIFICATION_ON = 5228 "wimax_networks_available_notification_on"; 5229 5230 /** 5231 * Delay (in seconds) before repeating the Wi-Fi networks available notification. 5232 * Connecting to a network will reset the timer. 5233 */ 5234 public static final String WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY = 5235 "wifi_networks_available_repeat_delay"; 5236 5237 /** 5238 * 802.11 country code in ISO 3166 format 5239 * @hide 5240 */ 5241 public static final String WIFI_COUNTRY_CODE = "wifi_country_code"; 5242 5243 /** 5244 * The interval in milliseconds to issue wake up scans when wifi needs 5245 * to connect. This is necessary to connect to an access point when 5246 * device is on the move and the screen is off. 5247 * @hide 5248 */ 5249 public static final String WIFI_FRAMEWORK_SCAN_INTERVAL_MS = 5250 "wifi_framework_scan_interval_ms"; 5251 5252 /** 5253 * The interval in milliseconds after which Wi-Fi is considered idle. 5254 * When idle, it is possible for the device to be switched from Wi-Fi to 5255 * the mobile data network. 5256 * @hide 5257 */ 5258 public static final String WIFI_IDLE_MS = "wifi_idle_ms"; 5259 5260 /** 5261 * When the number of open networks exceeds this number, the 5262 * least-recently-used excess networks will be removed. 5263 */ 5264 public static final String WIFI_NUM_OPEN_NETWORKS_KEPT = "wifi_num_open_networks_kept"; 5265 5266 /** 5267 * Whether the Wi-Fi should be on. Only the Wi-Fi service should touch this. 5268 */ 5269 public static final String WIFI_ON = "wifi_on"; 5270 5271 /** 5272 * Setting to allow scans to be enabled even wifi is turned off for connectivity. 5273 * @hide 5274 */ 5275 public static final String WIFI_SCAN_ALWAYS_AVAILABLE = 5276 "wifi_scan_always_enabled"; 5277 5278 /** 5279 * Used to save the Wifi_ON state prior to tethering. 5280 * This state will be checked to restore Wifi after 5281 * the user turns off tethering. 5282 * 5283 * @hide 5284 */ 5285 public static final String WIFI_SAVED_STATE = "wifi_saved_state"; 5286 5287 /** 5288 * The interval in milliseconds to scan as used by the wifi supplicant 5289 * @hide 5290 */ 5291 public static final String WIFI_SUPPLICANT_SCAN_INTERVAL_MS = 5292 "wifi_supplicant_scan_interval_ms"; 5293 5294 /** 5295 * The interval in milliseconds to scan at supplicant when p2p is connected 5296 * @hide 5297 */ 5298 public static final String WIFI_SCAN_INTERVAL_WHEN_P2P_CONNECTED_MS = 5299 "wifi_scan_interval_p2p_connected_ms"; 5300 5301 /** 5302 * Whether the Wi-Fi watchdog is enabled. 5303 */ 5304 public static final String WIFI_WATCHDOG_ON = "wifi_watchdog_on"; 5305 5306 /** 5307 * Setting to turn off poor network avoidance on Wi-Fi. Feature is enabled by default and 5308 * the setting needs to be set to 0 to disable it. 5309 * @hide 5310 */ 5311 public static final String WIFI_WATCHDOG_POOR_NETWORK_TEST_ENABLED = 5312 "wifi_watchdog_poor_network_test_enabled"; 5313 5314 /** 5315 * Setting to turn on suspend optimizations at screen off on Wi-Fi. Enabled by default and 5316 * needs to be set to 0 to disable it. 5317 * @hide 5318 */ 5319 public static final String WIFI_SUSPEND_OPTIMIZATIONS_ENABLED = 5320 "wifi_suspend_optimizations_enabled"; 5321 5322 /** 5323 * The maximum number of times we will retry a connection to an access 5324 * point for which we have failed in acquiring an IP address from DHCP. 5325 * A value of N means that we will make N+1 connection attempts in all. 5326 */ 5327 public static final String WIFI_MAX_DHCP_RETRY_COUNT = "wifi_max_dhcp_retry_count"; 5328 5329 /** 5330 * Maximum amount of time in milliseconds to hold a wakelock while waiting for mobile 5331 * data connectivity to be established after a disconnect from Wi-Fi. 5332 */ 5333 public static final String WIFI_MOBILE_DATA_TRANSITION_WAKELOCK_TIMEOUT_MS = 5334 "wifi_mobile_data_transition_wakelock_timeout_ms"; 5335 5336 /** 5337 * The operational wifi frequency band 5338 * Set to one of {@link WifiManager#WIFI_FREQUENCY_BAND_AUTO}, 5339 * {@link WifiManager#WIFI_FREQUENCY_BAND_5GHZ} or 5340 * {@link WifiManager#WIFI_FREQUENCY_BAND_2GHZ} 5341 * 5342 * @hide 5343 */ 5344 public static final String WIFI_FREQUENCY_BAND = "wifi_frequency_band"; 5345 5346 /** 5347 * The Wi-Fi peer-to-peer device name 5348 * @hide 5349 */ 5350 public static final String WIFI_P2P_DEVICE_NAME = "wifi_p2p_device_name"; 5351 5352 /** 5353 * The min time between wifi disable and wifi enable 5354 * @hide 5355 */ 5356 public static final String WIFI_REENABLE_DELAY_MS = "wifi_reenable_delay"; 5357 5358 /** 5359 * The number of milliseconds to delay when checking for data stalls during 5360 * non-aggressive detection. (screen is turned off.) 5361 * @hide 5362 */ 5363 public static final String DATA_STALL_ALARM_NON_AGGRESSIVE_DELAY_IN_MS = 5364 "data_stall_alarm_non_aggressive_delay_in_ms"; 5365 5366 /** 5367 * The number of milliseconds to delay when checking for data stalls during 5368 * aggressive detection. (screen on or suspected data stall) 5369 * @hide 5370 */ 5371 public static final String DATA_STALL_ALARM_AGGRESSIVE_DELAY_IN_MS = 5372 "data_stall_alarm_aggressive_delay_in_ms"; 5373 5374 /** 5375 * The number of milliseconds to allow the provisioning apn to remain active 5376 * @hide 5377 */ 5378 public static final String PROVISIONING_APN_ALARM_DELAY_IN_MS = 5379 "provisioning_apn_alarm_delay_in_ms"; 5380 5381 /** 5382 * The interval in milliseconds at which to check gprs registration 5383 * after the first registration mismatch of gprs and voice service, 5384 * to detect possible data network registration problems. 5385 * 5386 * @hide 5387 */ 5388 public static final String GPRS_REGISTER_CHECK_PERIOD_MS = 5389 "gprs_register_check_period_ms"; 5390 5391 /** 5392 * Nonzero causes Log.wtf() to crash. 5393 * @hide 5394 */ 5395 public static final String WTF_IS_FATAL = "wtf_is_fatal"; 5396 5397 /** 5398 * Ringer mode. This is used internally, changing this value will not 5399 * change the ringer mode. See AudioManager. 5400 */ 5401 public static final String MODE_RINGER = "mode_ringer"; 5402 5403 /** 5404 * Overlay display devices setting. 5405 * The associated value is a specially formatted string that describes the 5406 * size and density of simulated secondary display devices. 5407 * <p> 5408 * Format: {width}x{height}/{dpi};... 5409 * </p><p> 5410 * Example: 5411 * <ul> 5412 * <li><code>1280x720/213</code>: make one overlay that is 1280x720 at 213dpi.</li> 5413 * <li><code>1920x1080/320;1280x720/213</code>: make two overlays, the first 5414 * at 1080p and the second at 720p.</li> 5415 * <li>If the value is empty, then no overlay display devices are created.</li> 5416 * </ul></p> 5417 * 5418 * @hide 5419 */ 5420 public static final String OVERLAY_DISPLAY_DEVICES = "overlay_display_devices"; 5421 5422 /** 5423 * Threshold values for the duration and level of a discharge cycle, 5424 * under which we log discharge cycle info. 5425 * 5426 * @hide 5427 */ 5428 public static final String 5429 BATTERY_DISCHARGE_DURATION_THRESHOLD = "battery_discharge_duration_threshold"; 5430 5431 /** @hide */ 5432 public static final String BATTERY_DISCHARGE_THRESHOLD = "battery_discharge_threshold"; 5433 5434 /** 5435 * Flag for allowing ActivityManagerService to send ACTION_APP_ERROR 5436 * intents on application crashes and ANRs. If this is disabled, the 5437 * crash/ANR dialog will never display the "Report" button. 5438 * <p> 5439 * Type: int (0 = disallow, 1 = allow) 5440 * 5441 * @hide 5442 */ 5443 public static final String SEND_ACTION_APP_ERROR = "send_action_app_error"; 5444 5445 /** 5446 * Maximum age of entries kept by {@link DropBoxManager}. 5447 * 5448 * @hide 5449 */ 5450 public static final String DROPBOX_AGE_SECONDS = "dropbox_age_seconds"; 5451 5452 /** 5453 * Maximum number of entry files which {@link DropBoxManager} will keep 5454 * around. 5455 * 5456 * @hide 5457 */ 5458 public static final String DROPBOX_MAX_FILES = "dropbox_max_files"; 5459 5460 /** 5461 * Maximum amount of disk space used by {@link DropBoxManager} no matter 5462 * what. 5463 * 5464 * @hide 5465 */ 5466 public static final String DROPBOX_QUOTA_KB = "dropbox_quota_kb"; 5467 5468 /** 5469 * Percent of free disk (excluding reserve) which {@link DropBoxManager} 5470 * will use. 5471 * 5472 * @hide 5473 */ 5474 public static final String DROPBOX_QUOTA_PERCENT = "dropbox_quota_percent"; 5475 5476 /** 5477 * Percent of total disk which {@link DropBoxManager} will never dip 5478 * into. 5479 * 5480 * @hide 5481 */ 5482 public static final String DROPBOX_RESERVE_PERCENT = "dropbox_reserve_percent"; 5483 5484 /** 5485 * Prefix for per-tag dropbox disable/enable settings. 5486 * 5487 * @hide 5488 */ 5489 public static final String DROPBOX_TAG_PREFIX = "dropbox:"; 5490 5491 /** 5492 * Lines of logcat to include with system crash/ANR/etc. reports, as a 5493 * prefix of the dropbox tag of the report type. For example, 5494 * "logcat_for_system_server_anr" controls the lines of logcat captured 5495 * with system server ANR reports. 0 to disable. 5496 * 5497 * @hide 5498 */ 5499 public static final String ERROR_LOGCAT_PREFIX = "logcat_for_"; 5500 5501 /** 5502 * The interval in minutes after which the amount of free storage left 5503 * on the device is logged to the event log 5504 * 5505 * @hide 5506 */ 5507 public static final String SYS_FREE_STORAGE_LOG_INTERVAL = "sys_free_storage_log_interval"; 5508 5509 /** 5510 * Threshold for the amount of change in disk free space required to 5511 * report the amount of free space. Used to prevent spamming the logs 5512 * when the disk free space isn't changing frequently. 5513 * 5514 * @hide 5515 */ 5516 public static final String 5517 DISK_FREE_CHANGE_REPORTING_THRESHOLD = "disk_free_change_reporting_threshold"; 5518 5519 /** 5520 * Minimum percentage of free storage on the device that is used to 5521 * determine if the device is running low on storage. The default is 10. 5522 * <p> 5523 * Say this value is set to 10, the device is considered running low on 5524 * storage if 90% or more of the device storage is filled up. 5525 * 5526 * @hide 5527 */ 5528 public static final String 5529 SYS_STORAGE_THRESHOLD_PERCENTAGE = "sys_storage_threshold_percentage"; 5530 5531 /** 5532 * Maximum byte size of the low storage threshold. This is to ensure 5533 * that {@link #SYS_STORAGE_THRESHOLD_PERCENTAGE} does not result in an 5534 * overly large threshold for large storage devices. Currently this must 5535 * be less than 2GB. This default is 500MB. 5536 * 5537 * @hide 5538 */ 5539 public static final String 5540 SYS_STORAGE_THRESHOLD_MAX_BYTES = "sys_storage_threshold_max_bytes"; 5541 5542 /** 5543 * Minimum bytes of free storage on the device before the data partition 5544 * is considered full. By default, 1 MB is reserved to avoid system-wide 5545 * SQLite disk full exceptions. 5546 * 5547 * @hide 5548 */ 5549 public static final String 5550 SYS_STORAGE_FULL_THRESHOLD_BYTES = "sys_storage_full_threshold_bytes"; 5551 5552 /** 5553 * The maximum reconnect delay for short network outages or when the 5554 * network is suspended due to phone use. 5555 * 5556 * @hide 5557 */ 5558 public static final String 5559 SYNC_MAX_RETRY_DELAY_IN_SECONDS = "sync_max_retry_delay_in_seconds"; 5560 5561 /** 5562 * The number of milliseconds to delay before sending out 5563 * {@link ConnectivityManager#CONNECTIVITY_ACTION} broadcasts. 5564 * 5565 * @hide 5566 */ 5567 public static final String CONNECTIVITY_CHANGE_DELAY = "connectivity_change_delay"; 5568 5569 5570 /** 5571 * Network sampling interval, in seconds. We'll generate link information 5572 * about bytes/packets sent and error rates based on data sampled in this interval 5573 * 5574 * @hide 5575 */ 5576 5577 public static final String CONNECTIVITY_SAMPLING_INTERVAL_IN_SECONDS = 5578 "connectivity_sampling_interval_in_seconds"; 5579 5580 /** 5581 * The series of successively longer delays used in retrying to download PAC file. 5582 * Last delay is used between successful PAC downloads. 5583 * 5584 * @hide 5585 */ 5586 public static final String PAC_CHANGE_DELAY = "pac_change_delay"; 5587 5588 /** 5589 * Setting to turn off captive portal detection. Feature is enabled by 5590 * default and the setting needs to be set to 0 to disable it. 5591 * 5592 * @hide 5593 */ 5594 public static final String 5595 CAPTIVE_PORTAL_DETECTION_ENABLED = "captive_portal_detection_enabled"; 5596 5597 /** 5598 * The server used for captive portal detection upon a new conection. A 5599 * 204 response code from the server is used for validation. 5600 * 5601 * @hide 5602 */ 5603 public static final String CAPTIVE_PORTAL_SERVER = "captive_portal_server"; 5604 5605 /** 5606 * Whether network service discovery is enabled. 5607 * 5608 * @hide 5609 */ 5610 public static final String NSD_ON = "nsd_on"; 5611 5612 /** 5613 * Let user pick default install location. 5614 * 5615 * @hide 5616 */ 5617 public static final String SET_INSTALL_LOCATION = "set_install_location"; 5618 5619 /** 5620 * Default install location value. 5621 * 0 = auto, let system decide 5622 * 1 = internal 5623 * 2 = sdcard 5624 * @hide 5625 */ 5626 public static final String DEFAULT_INSTALL_LOCATION = "default_install_location"; 5627 5628 /** 5629 * ms during which to consume extra events related to Inet connection 5630 * condition after a transtion to fully-connected 5631 * 5632 * @hide 5633 */ 5634 public static final String 5635 INET_CONDITION_DEBOUNCE_UP_DELAY = "inet_condition_debounce_up_delay"; 5636 5637 /** 5638 * ms during which to consume extra events related to Inet connection 5639 * condtion after a transtion to partly-connected 5640 * 5641 * @hide 5642 */ 5643 public static final String 5644 INET_CONDITION_DEBOUNCE_DOWN_DELAY = "inet_condition_debounce_down_delay"; 5645 5646 /** {@hide} */ 5647 public static final String 5648 READ_EXTERNAL_STORAGE_ENFORCED_DEFAULT = "read_external_storage_enforced_default"; 5649 5650 /** 5651 * Host name and port for global http proxy. Uses ':' seperator for 5652 * between host and port. 5653 */ 5654 public static final String HTTP_PROXY = "http_proxy"; 5655 5656 /** 5657 * Host name for global http proxy. Set via ConnectivityManager. 5658 * 5659 * @hide 5660 */ 5661 public static final String GLOBAL_HTTP_PROXY_HOST = "global_http_proxy_host"; 5662 5663 /** 5664 * Integer host port for global http proxy. Set via ConnectivityManager. 5665 * 5666 * @hide 5667 */ 5668 public static final String GLOBAL_HTTP_PROXY_PORT = "global_http_proxy_port"; 5669 5670 /** 5671 * Exclusion list for global proxy. This string contains a list of 5672 * comma-separated domains where the global proxy does not apply. 5673 * Domains should be listed in a comma- separated list. Example of 5674 * acceptable formats: ".domain1.com,my.domain2.com" Use 5675 * ConnectivityManager to set/get. 5676 * 5677 * @hide 5678 */ 5679 public static final String 5680 GLOBAL_HTTP_PROXY_EXCLUSION_LIST = "global_http_proxy_exclusion_list"; 5681 5682 /** 5683 * The location PAC File for the proxy. 5684 * @hide 5685 */ 5686 public static final String 5687 GLOBAL_HTTP_PROXY_PAC = "global_proxy_pac_url"; 5688 5689 /** 5690 * Enables the UI setting to allow the user to specify the global HTTP 5691 * proxy and associated exclusion list. 5692 * 5693 * @hide 5694 */ 5695 public static final String SET_GLOBAL_HTTP_PROXY = "set_global_http_proxy"; 5696 5697 /** 5698 * Setting for default DNS in case nobody suggests one 5699 * 5700 * @hide 5701 */ 5702 public static final String DEFAULT_DNS_SERVER = "default_dns_server"; 5703 5704 /** {@hide} */ 5705 public static final String 5706 BLUETOOTH_HEADSET_PRIORITY_PREFIX = "bluetooth_headset_priority_"; 5707 /** {@hide} */ 5708 public static final String 5709 BLUETOOTH_A2DP_SINK_PRIORITY_PREFIX = "bluetooth_a2dp_sink_priority_"; 5710 /** {@hide} */ 5711 public static final String 5712 BLUETOOTH_INPUT_DEVICE_PRIORITY_PREFIX = "bluetooth_input_device_priority_"; 5713 /** {@hide} */ 5714 public static final String 5715 BLUETOOTH_MAP_PRIORITY_PREFIX = "bluetooth_map_priority_"; 5716 5717 /** 5718 * Get the key that retrieves a bluetooth headset's priority. 5719 * @hide 5720 */ getBluetoothHeadsetPriorityKey(String address)5721 public static final String getBluetoothHeadsetPriorityKey(String address) { 5722 return BLUETOOTH_HEADSET_PRIORITY_PREFIX + address.toUpperCase(Locale.ROOT); 5723 } 5724 5725 /** 5726 * Get the key that retrieves a bluetooth a2dp sink's priority. 5727 * @hide 5728 */ getBluetoothA2dpSinkPriorityKey(String address)5729 public static final String getBluetoothA2dpSinkPriorityKey(String address) { 5730 return BLUETOOTH_A2DP_SINK_PRIORITY_PREFIX + address.toUpperCase(Locale.ROOT); 5731 } 5732 5733 /** 5734 * Get the key that retrieves a bluetooth Input Device's priority. 5735 * @hide 5736 */ getBluetoothInputDevicePriorityKey(String address)5737 public static final String getBluetoothInputDevicePriorityKey(String address) { 5738 return BLUETOOTH_INPUT_DEVICE_PRIORITY_PREFIX + address.toUpperCase(Locale.ROOT); 5739 } 5740 5741 /** 5742 * Get the key that retrieves a bluetooth map priority. 5743 * @hide 5744 */ getBluetoothMapPriorityKey(String address)5745 public static final String getBluetoothMapPriorityKey(String address) { 5746 return BLUETOOTH_MAP_PRIORITY_PREFIX + address.toUpperCase(Locale.ROOT); 5747 } 5748 /** 5749 * Scaling factor for normal window animations. Setting to 0 will 5750 * disable window animations. 5751 */ 5752 public static final String WINDOW_ANIMATION_SCALE = "window_animation_scale"; 5753 5754 /** 5755 * Scaling factor for activity transition animations. Setting to 0 will 5756 * disable window animations. 5757 */ 5758 public static final String TRANSITION_ANIMATION_SCALE = "transition_animation_scale"; 5759 5760 /** 5761 * Scaling factor for Animator-based animations. This affects both the 5762 * start delay and duration of all such animations. Setting to 0 will 5763 * cause animations to end immediately. The default value is 1. 5764 */ 5765 public static final String ANIMATOR_DURATION_SCALE = "animator_duration_scale"; 5766 5767 /** 5768 * Scaling factor for normal window animations. Setting to 0 will 5769 * disable window animations. 5770 * 5771 * @hide 5772 */ 5773 public static final String FANCY_IME_ANIMATIONS = "fancy_ime_animations"; 5774 5775 /** 5776 * If 0, the compatibility mode is off for all applications. 5777 * If 1, older applications run under compatibility mode. 5778 * TODO: remove this settings before code freeze (bug/1907571) 5779 * @hide 5780 */ 5781 public static final String COMPATIBILITY_MODE = "compatibility_mode"; 5782 5783 /** 5784 * CDMA only settings 5785 * Emergency Tone 0 = Off 5786 * 1 = Alert 5787 * 2 = Vibrate 5788 * @hide 5789 */ 5790 public static final String EMERGENCY_TONE = "emergency_tone"; 5791 5792 /** 5793 * CDMA only settings 5794 * Whether the auto retry is enabled. The value is 5795 * boolean (1 or 0). 5796 * @hide 5797 */ 5798 public static final String CALL_AUTO_RETRY = "call_auto_retry"; 5799 5800 /** 5801 * The preferred network mode 7 = Global 5802 * 6 = EvDo only 5803 * 5 = CDMA w/o EvDo 5804 * 4 = CDMA / EvDo auto 5805 * 3 = GSM / WCDMA auto 5806 * 2 = WCDMA only 5807 * 1 = GSM only 5808 * 0 = GSM / WCDMA preferred 5809 * @hide 5810 */ 5811 public static final String PREFERRED_NETWORK_MODE = 5812 "preferred_network_mode"; 5813 5814 /** 5815 * Name of an application package to be debugged. 5816 */ 5817 public static final String DEBUG_APP = "debug_app"; 5818 5819 /** 5820 * If 1, when launching DEBUG_APP it will wait for the debugger before 5821 * starting user code. If 0, it will run normally. 5822 */ 5823 public static final String WAIT_FOR_DEBUGGER = "wait_for_debugger"; 5824 5825 /** 5826 * Control whether the process CPU usage meter should be shown. 5827 */ 5828 public static final String SHOW_PROCESSES = "show_processes"; 5829 5830 /** 5831 * If 1, the activity manager will aggressively finish activities and 5832 * processes as soon as they are no longer needed. If 0, the normal 5833 * extended lifetime is used. 5834 */ 5835 public static final String ALWAYS_FINISH_ACTIVITIES = 5836 "always_finish_activities"; 5837 5838 /** 5839 * Use Dock audio output for media: 5840 * 0 = disabled 5841 * 1 = enabled 5842 * @hide 5843 */ 5844 public static final String DOCK_AUDIO_MEDIA_ENABLED = "dock_audio_media_enabled"; 5845 5846 /** 5847 * Persisted safe headphone volume management state by AudioService 5848 * @hide 5849 */ 5850 public static final String AUDIO_SAFE_VOLUME_STATE = "audio_safe_volume_state"; 5851 5852 /** 5853 * URL for tzinfo (time zone) updates 5854 * @hide 5855 */ 5856 public static final String TZINFO_UPDATE_CONTENT_URL = "tzinfo_content_url"; 5857 5858 /** 5859 * URL for tzinfo (time zone) update metadata 5860 * @hide 5861 */ 5862 public static final String TZINFO_UPDATE_METADATA_URL = "tzinfo_metadata_url"; 5863 5864 /** 5865 * URL for selinux (mandatory access control) updates 5866 * @hide 5867 */ 5868 public static final String SELINUX_UPDATE_CONTENT_URL = "selinux_content_url"; 5869 5870 /** 5871 * URL for selinux (mandatory access control) update metadata 5872 * @hide 5873 */ 5874 public static final String SELINUX_UPDATE_METADATA_URL = "selinux_metadata_url"; 5875 5876 /** 5877 * URL for sms short code updates 5878 * @hide 5879 */ 5880 public static final String SMS_SHORT_CODES_UPDATE_CONTENT_URL = 5881 "sms_short_codes_content_url"; 5882 5883 /** 5884 * URL for sms short code update metadata 5885 * @hide 5886 */ 5887 public static final String SMS_SHORT_CODES_UPDATE_METADATA_URL = 5888 "sms_short_codes_metadata_url"; 5889 5890 /** 5891 * URL for cert pinlist updates 5892 * @hide 5893 */ 5894 public static final String CERT_PIN_UPDATE_CONTENT_URL = "cert_pin_content_url"; 5895 5896 /** 5897 * URL for cert pinlist updates 5898 * @hide 5899 */ 5900 public static final String CERT_PIN_UPDATE_METADATA_URL = "cert_pin_metadata_url"; 5901 5902 /** 5903 * URL for intent firewall updates 5904 * @hide 5905 */ 5906 public static final String INTENT_FIREWALL_UPDATE_CONTENT_URL = 5907 "intent_firewall_content_url"; 5908 5909 /** 5910 * URL for intent firewall update metadata 5911 * @hide 5912 */ 5913 public static final String INTENT_FIREWALL_UPDATE_METADATA_URL = 5914 "intent_firewall_metadata_url"; 5915 5916 /** 5917 * SELinux enforcement status. If 0, permissive; if 1, enforcing. 5918 * @hide 5919 */ 5920 public static final String SELINUX_STATUS = "selinux_status"; 5921 5922 /** 5923 * Developer setting to force RTL layout. 5924 * @hide 5925 */ 5926 public static final String DEVELOPMENT_FORCE_RTL = "debug.force_rtl"; 5927 5928 /** 5929 * Milliseconds after screen-off after which low battery sounds will be silenced. 5930 * 5931 * If zero, battery sounds will always play. 5932 * Defaults to @integer/def_low_battery_sound_timeout in SettingsProvider. 5933 * 5934 * @hide 5935 */ 5936 public static final String LOW_BATTERY_SOUND_TIMEOUT = "low_battery_sound_timeout"; 5937 5938 /** 5939 * Settings to backup. This is here so that it's in the same place as the settings 5940 * keys and easy to update. 5941 * 5942 * These keys may be mentioned in the SETTINGS_TO_BACKUP arrays in System 5943 * and Secure as well. This is because those tables drive both backup and 5944 * restore, and restore needs to properly whitelist keys that used to live 5945 * in those namespaces. The keys will only actually be backed up / restored 5946 * if they are also mentioned in this table (Global.SETTINGS_TO_BACKUP). 5947 * 5948 * NOTE: Settings are backed up and restored in the order they appear 5949 * in this array. If you have one setting depending on another, 5950 * make sure that they are ordered appropriately. 5951 * 5952 * @hide 5953 */ 5954 public static final String[] SETTINGS_TO_BACKUP = { 5955 BUGREPORT_IN_POWER_MENU, 5956 STAY_ON_WHILE_PLUGGED_IN, 5957 AUTO_TIME, 5958 AUTO_TIME_ZONE, 5959 POWER_SOUNDS_ENABLED, 5960 DOCK_SOUNDS_ENABLED, 5961 USB_MASS_STORAGE_ENABLED, 5962 ENABLE_ACCESSIBILITY_GLOBAL_GESTURE_ENABLED, 5963 WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON, 5964 WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY, 5965 WIFI_WATCHDOG_POOR_NETWORK_TEST_ENABLED, 5966 WIFI_NUM_OPEN_NETWORKS_KEPT, 5967 EMERGENCY_TONE, 5968 CALL_AUTO_RETRY, 5969 DOCK_AUDIO_MEDIA_ENABLED 5970 }; 5971 5972 // Populated lazily, guarded by class object: 5973 private static NameValueCache sNameValueCache = new NameValueCache( 5974 SYS_PROP_SETTING_VERSION, 5975 CONTENT_URI, 5976 CALL_METHOD_GET_GLOBAL, 5977 CALL_METHOD_PUT_GLOBAL); 5978 5979 /** 5980 * Look up a name in the database. 5981 * @param resolver to access the database with 5982 * @param name to look up in the table 5983 * @return the corresponding value, or null if not present 5984 */ getString(ContentResolver resolver, String name)5985 public static String getString(ContentResolver resolver, String name) { 5986 return getStringForUser(resolver, name, UserHandle.myUserId()); 5987 } 5988 5989 /** @hide */ getStringForUser(ContentResolver resolver, String name, int userHandle)5990 public static String getStringForUser(ContentResolver resolver, String name, 5991 int userHandle) { 5992 return sNameValueCache.getStringForUser(resolver, name, userHandle); 5993 } 5994 5995 /** 5996 * Store a name/value pair into the database. 5997 * @param resolver to access the database with 5998 * @param name to store 5999 * @param value to associate with the name 6000 * @return true if the value was set, false on database errors 6001 */ putString(ContentResolver resolver, String name, String value)6002 public static boolean putString(ContentResolver resolver, 6003 String name, String value) { 6004 return putStringForUser(resolver, name, value, UserHandle.myUserId()); 6005 } 6006 6007 /** @hide */ putStringForUser(ContentResolver resolver, String name, String value, int userHandle)6008 public static boolean putStringForUser(ContentResolver resolver, 6009 String name, String value, int userHandle) { 6010 if (LOCAL_LOGV) { 6011 Log.v(TAG, "Global.putString(name=" + name + ", value=" + value 6012 + " for " + userHandle); 6013 } 6014 return sNameValueCache.putStringForUser(resolver, name, value, userHandle); 6015 } 6016 6017 /** 6018 * Construct the content URI for a particular name/value pair, 6019 * useful for monitoring changes with a ContentObserver. 6020 * @param name to look up in the table 6021 * @return the corresponding content URI, or null if not present 6022 */ getUriFor(String name)6023 public static Uri getUriFor(String name) { 6024 return getUriFor(CONTENT_URI, name); 6025 } 6026 6027 /** 6028 * Convenience function for retrieving a single secure settings value 6029 * as an integer. Note that internally setting values are always 6030 * stored as strings; this function converts the string to an integer 6031 * for you. The default value will be returned if the setting is 6032 * not defined or not an integer. 6033 * 6034 * @param cr The ContentResolver to access. 6035 * @param name The name of the setting to retrieve. 6036 * @param def Value to return if the setting is not defined. 6037 * 6038 * @return The setting's current value, or 'def' if it is not defined 6039 * or not a valid integer. 6040 */ getInt(ContentResolver cr, String name, int def)6041 public static int getInt(ContentResolver cr, String name, int def) { 6042 String v = getString(cr, name); 6043 try { 6044 return v != null ? Integer.parseInt(v) : def; 6045 } catch (NumberFormatException e) { 6046 return def; 6047 } 6048 } 6049 6050 /** 6051 * Convenience function for retrieving a single secure settings value 6052 * as an integer. Note that internally setting values are always 6053 * stored as strings; this function converts the string to an integer 6054 * for you. 6055 * <p> 6056 * This version does not take a default value. If the setting has not 6057 * been set, or the string value is not a number, 6058 * it throws {@link SettingNotFoundException}. 6059 * 6060 * @param cr The ContentResolver to access. 6061 * @param name The name of the setting to retrieve. 6062 * 6063 * @throws SettingNotFoundException Thrown if a setting by the given 6064 * name can't be found or the setting value is not an integer. 6065 * 6066 * @return The setting's current value. 6067 */ getInt(ContentResolver cr, String name)6068 public static int getInt(ContentResolver cr, String name) 6069 throws SettingNotFoundException { 6070 String v = getString(cr, name); 6071 try { 6072 return Integer.parseInt(v); 6073 } catch (NumberFormatException e) { 6074 throw new SettingNotFoundException(name); 6075 } 6076 } 6077 6078 /** 6079 * Convenience function for updating a single settings value as an 6080 * integer. This will either create a new entry in the table if the 6081 * given name does not exist, or modify the value of the existing row 6082 * with that name. Note that internally setting values are always 6083 * stored as strings, so this function converts the given value to a 6084 * string before storing it. 6085 * 6086 * @param cr The ContentResolver to access. 6087 * @param name The name of the setting to modify. 6088 * @param value The new value for the setting. 6089 * @return true if the value was set, false on database errors 6090 */ putInt(ContentResolver cr, String name, int value)6091 public static boolean putInt(ContentResolver cr, String name, int value) { 6092 return putString(cr, name, Integer.toString(value)); 6093 } 6094 6095 /** 6096 * Convenience function for retrieving a single secure settings value 6097 * as a {@code long}. Note that internally setting values are always 6098 * stored as strings; this function converts the string to a {@code long} 6099 * for you. The default value will be returned if the setting is 6100 * not defined or not a {@code long}. 6101 * 6102 * @param cr The ContentResolver to access. 6103 * @param name The name of the setting to retrieve. 6104 * @param def Value to return if the setting is not defined. 6105 * 6106 * @return The setting's current value, or 'def' if it is not defined 6107 * or not a valid {@code long}. 6108 */ getLong(ContentResolver cr, String name, long def)6109 public static long getLong(ContentResolver cr, String name, long def) { 6110 String valString = getString(cr, name); 6111 long value; 6112 try { 6113 value = valString != null ? Long.parseLong(valString) : def; 6114 } catch (NumberFormatException e) { 6115 value = def; 6116 } 6117 return value; 6118 } 6119 6120 /** 6121 * Convenience function for retrieving a single secure settings value 6122 * as a {@code long}. Note that internally setting values are always 6123 * stored as strings; this function converts the string to a {@code long} 6124 * for you. 6125 * <p> 6126 * This version does not take a default value. If the setting has not 6127 * been set, or the string value is not a number, 6128 * it throws {@link SettingNotFoundException}. 6129 * 6130 * @param cr The ContentResolver to access. 6131 * @param name The name of the setting to retrieve. 6132 * 6133 * @return The setting's current value. 6134 * @throws SettingNotFoundException Thrown if a setting by the given 6135 * name can't be found or the setting value is not an integer. 6136 */ getLong(ContentResolver cr, String name)6137 public static long getLong(ContentResolver cr, String name) 6138 throws SettingNotFoundException { 6139 String valString = getString(cr, name); 6140 try { 6141 return Long.parseLong(valString); 6142 } catch (NumberFormatException e) { 6143 throw new SettingNotFoundException(name); 6144 } 6145 } 6146 6147 /** 6148 * Convenience function for updating a secure settings value as a long 6149 * integer. This will either create a new entry in the table if the 6150 * given name does not exist, or modify the value of the existing row 6151 * with that name. Note that internally setting values are always 6152 * stored as strings, so this function converts the given value to a 6153 * string before storing it. 6154 * 6155 * @param cr The ContentResolver to access. 6156 * @param name The name of the setting to modify. 6157 * @param value The new value for the setting. 6158 * @return true if the value was set, false on database errors 6159 */ putLong(ContentResolver cr, String name, long value)6160 public static boolean putLong(ContentResolver cr, String name, long value) { 6161 return putString(cr, name, Long.toString(value)); 6162 } 6163 6164 /** 6165 * Convenience function for retrieving a single secure settings value 6166 * as a floating point number. Note that internally setting values are 6167 * always stored as strings; this function converts the string to an 6168 * float for you. The default value will be returned if the setting 6169 * is not defined or not a valid float. 6170 * 6171 * @param cr The ContentResolver to access. 6172 * @param name The name of the setting to retrieve. 6173 * @param def Value to return if the setting is not defined. 6174 * 6175 * @return The setting's current value, or 'def' if it is not defined 6176 * or not a valid float. 6177 */ getFloat(ContentResolver cr, String name, float def)6178 public static float getFloat(ContentResolver cr, String name, float def) { 6179 String v = getString(cr, name); 6180 try { 6181 return v != null ? Float.parseFloat(v) : def; 6182 } catch (NumberFormatException e) { 6183 return def; 6184 } 6185 } 6186 6187 /** 6188 * Convenience function for retrieving a single secure settings value 6189 * as a float. Note that internally setting values are always 6190 * stored as strings; this function converts the string to a float 6191 * for you. 6192 * <p> 6193 * This version does not take a default value. If the setting has not 6194 * been set, or the string value is not a number, 6195 * it throws {@link SettingNotFoundException}. 6196 * 6197 * @param cr The ContentResolver to access. 6198 * @param name The name of the setting to retrieve. 6199 * 6200 * @throws SettingNotFoundException Thrown if a setting by the given 6201 * name can't be found or the setting value is not a float. 6202 * 6203 * @return The setting's current value. 6204 */ getFloat(ContentResolver cr, String name)6205 public static float getFloat(ContentResolver cr, String name) 6206 throws SettingNotFoundException { 6207 String v = getString(cr, name); 6208 if (v == null) { 6209 throw new SettingNotFoundException(name); 6210 } 6211 try { 6212 return Float.parseFloat(v); 6213 } catch (NumberFormatException e) { 6214 throw new SettingNotFoundException(name); 6215 } 6216 } 6217 6218 /** 6219 * Convenience function for updating a single settings value as a 6220 * floating point number. This will either create a new entry in the 6221 * table if the given name does not exist, or modify the value of the 6222 * existing row with that name. Note that internally setting values 6223 * are always stored as strings, so this function converts the given 6224 * value to a string before storing it. 6225 * 6226 * @param cr The ContentResolver to access. 6227 * @param name The name of the setting to modify. 6228 * @param value The new value for the setting. 6229 * @return true if the value was set, false on database errors 6230 */ putFloat(ContentResolver cr, String name, float value)6231 public static boolean putFloat(ContentResolver cr, String name, float value) { 6232 return putString(cr, name, Float.toString(value)); 6233 } 6234 } 6235 6236 /** 6237 * User-defined bookmarks and shortcuts. The target of each bookmark is an 6238 * Intent URL, allowing it to be either a web page or a particular 6239 * application activity. 6240 * 6241 * @hide 6242 */ 6243 public static final class Bookmarks implements BaseColumns 6244 { 6245 private static final String TAG = "Bookmarks"; 6246 6247 /** 6248 * The content:// style URL for this table 6249 */ 6250 public static final Uri CONTENT_URI = 6251 Uri.parse("content://" + AUTHORITY + "/bookmarks"); 6252 6253 /** 6254 * The row ID. 6255 * <p>Type: INTEGER</p> 6256 */ 6257 public static final String ID = "_id"; 6258 6259 /** 6260 * Descriptive name of the bookmark that can be displayed to the user. 6261 * If this is empty, the title should be resolved at display time (use 6262 * {@link #getTitle(Context, Cursor)} any time you want to display the 6263 * title of a bookmark.) 6264 * <P> 6265 * Type: TEXT 6266 * </P> 6267 */ 6268 public static final String TITLE = "title"; 6269 6270 /** 6271 * Arbitrary string (displayed to the user) that allows bookmarks to be 6272 * organized into categories. There are some special names for 6273 * standard folders, which all start with '@'. The label displayed for 6274 * the folder changes with the locale (via {@link #getLabelForFolder}) but 6275 * the folder name does not change so you can consistently query for 6276 * the folder regardless of the current locale. 6277 * 6278 * <P>Type: TEXT</P> 6279 * 6280 */ 6281 public static final String FOLDER = "folder"; 6282 6283 /** 6284 * The Intent URL of the bookmark, describing what it points to. This 6285 * value is given to {@link android.content.Intent#getIntent} to create 6286 * an Intent that can be launched. 6287 * <P>Type: TEXT</P> 6288 */ 6289 public static final String INTENT = "intent"; 6290 6291 /** 6292 * Optional shortcut character associated with this bookmark. 6293 * <P>Type: INTEGER</P> 6294 */ 6295 public static final String SHORTCUT = "shortcut"; 6296 6297 /** 6298 * The order in which the bookmark should be displayed 6299 * <P>Type: INTEGER</P> 6300 */ 6301 public static final String ORDERING = "ordering"; 6302 6303 private static final String[] sIntentProjection = { INTENT }; 6304 private static final String[] sShortcutProjection = { ID, SHORTCUT }; 6305 private static final String sShortcutSelection = SHORTCUT + "=?"; 6306 6307 /** 6308 * Convenience function to retrieve the bookmarked Intent for a 6309 * particular shortcut key. 6310 * 6311 * @param cr The ContentResolver to query. 6312 * @param shortcut The shortcut key. 6313 * 6314 * @return Intent The bookmarked URL, or null if there is no bookmark 6315 * matching the given shortcut. 6316 */ getIntentForShortcut(ContentResolver cr, char shortcut)6317 public static Intent getIntentForShortcut(ContentResolver cr, char shortcut) 6318 { 6319 Intent intent = null; 6320 6321 Cursor c = cr.query(CONTENT_URI, 6322 sIntentProjection, sShortcutSelection, 6323 new String[] { String.valueOf((int) shortcut) }, ORDERING); 6324 // Keep trying until we find a valid shortcut 6325 try { 6326 while (intent == null && c.moveToNext()) { 6327 try { 6328 String intentURI = c.getString(c.getColumnIndexOrThrow(INTENT)); 6329 intent = Intent.parseUri(intentURI, 0); 6330 } catch (java.net.URISyntaxException e) { 6331 // The stored URL is bad... ignore it. 6332 } catch (IllegalArgumentException e) { 6333 // Column not found 6334 Log.w(TAG, "Intent column not found", e); 6335 } 6336 } 6337 } finally { 6338 if (c != null) c.close(); 6339 } 6340 6341 return intent; 6342 } 6343 6344 /** 6345 * Add a new bookmark to the system. 6346 * 6347 * @param cr The ContentResolver to query. 6348 * @param intent The desired target of the bookmark. 6349 * @param title Bookmark title that is shown to the user; null if none 6350 * or it should be resolved to the intent's title. 6351 * @param folder Folder in which to place the bookmark; null if none. 6352 * @param shortcut Shortcut that will invoke the bookmark; 0 if none. If 6353 * this is non-zero and there is an existing bookmark entry 6354 * with this same shortcut, then that existing shortcut is 6355 * cleared (the bookmark is not removed). 6356 * @return The unique content URL for the new bookmark entry. 6357 */ add(ContentResolver cr, Intent intent, String title, String folder, char shortcut, int ordering)6358 public static Uri add(ContentResolver cr, 6359 Intent intent, 6360 String title, 6361 String folder, 6362 char shortcut, 6363 int ordering) 6364 { 6365 // If a shortcut is supplied, and it is already defined for 6366 // another bookmark, then remove the old definition. 6367 if (shortcut != 0) { 6368 cr.delete(CONTENT_URI, sShortcutSelection, 6369 new String[] { String.valueOf((int) shortcut) }); 6370 } 6371 6372 ContentValues values = new ContentValues(); 6373 if (title != null) values.put(TITLE, title); 6374 if (folder != null) values.put(FOLDER, folder); 6375 values.put(INTENT, intent.toUri(0)); 6376 if (shortcut != 0) values.put(SHORTCUT, (int) shortcut); 6377 values.put(ORDERING, ordering); 6378 return cr.insert(CONTENT_URI, values); 6379 } 6380 6381 /** 6382 * Return the folder name as it should be displayed to the user. This 6383 * takes care of localizing special folders. 6384 * 6385 * @param r Resources object for current locale; only need access to 6386 * system resources. 6387 * @param folder The value found in the {@link #FOLDER} column. 6388 * 6389 * @return CharSequence The label for this folder that should be shown 6390 * to the user. 6391 */ getLabelForFolder(Resources r, String folder)6392 public static CharSequence getLabelForFolder(Resources r, String folder) { 6393 return folder; 6394 } 6395 6396 /** 6397 * Return the title as it should be displayed to the user. This takes 6398 * care of localizing bookmarks that point to activities. 6399 * 6400 * @param context A context. 6401 * @param cursor A cursor pointing to the row whose title should be 6402 * returned. The cursor must contain at least the {@link #TITLE} 6403 * and {@link #INTENT} columns. 6404 * @return A title that is localized and can be displayed to the user, 6405 * or the empty string if one could not be found. 6406 */ getTitle(Context context, Cursor cursor)6407 public static CharSequence getTitle(Context context, Cursor cursor) { 6408 int titleColumn = cursor.getColumnIndex(TITLE); 6409 int intentColumn = cursor.getColumnIndex(INTENT); 6410 if (titleColumn == -1 || intentColumn == -1) { 6411 throw new IllegalArgumentException( 6412 "The cursor must contain the TITLE and INTENT columns."); 6413 } 6414 6415 String title = cursor.getString(titleColumn); 6416 if (!TextUtils.isEmpty(title)) { 6417 return title; 6418 } 6419 6420 String intentUri = cursor.getString(intentColumn); 6421 if (TextUtils.isEmpty(intentUri)) { 6422 return ""; 6423 } 6424 6425 Intent intent; 6426 try { 6427 intent = Intent.parseUri(intentUri, 0); 6428 } catch (URISyntaxException e) { 6429 return ""; 6430 } 6431 6432 PackageManager packageManager = context.getPackageManager(); 6433 ResolveInfo info = packageManager.resolveActivity(intent, 0); 6434 return info != null ? info.loadLabel(packageManager) : ""; 6435 } 6436 } 6437 6438 /** 6439 * Returns the device ID that we should use when connecting to the mobile gtalk server. 6440 * This is a string like "android-0x1242", where the hex string is the Android ID obtained 6441 * from the GoogleLoginService. 6442 * 6443 * @param androidId The Android ID for this device. 6444 * @return The device ID that should be used when connecting to the mobile gtalk server. 6445 * @hide 6446 */ getGTalkDeviceId(long androidId)6447 public static String getGTalkDeviceId(long androidId) { 6448 return "android-" + Long.toHexString(androidId); 6449 } 6450 } 6451